﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.TraceVisualiser.Pics
{
	public static class PicLibrary22
	{
        #region Image ArrowLeft2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-left-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowLeft2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowLeft2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowLeft2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-left-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowLeft2_Cached
        {
            get
            {
                if (_ArrowLeft2 == null) _ArrowLeft2 = ArrowLeft2;
                return _ArrowLeft2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-left-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowLeft2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowLeft2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowLeft2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-left-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowLeft2 { get { return _ImageCreateFrom(_ArrowLeft2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-left-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowLeft2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowLeft2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-left-2.png
        /// </remarks>
        public static System.Drawing.Image ArrowLeft2_FromFile { get { return _ImageCreateFrom(_ArrowLeft2_string, "arrow-left-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowLeft2
        /// </summary>
        /// <returns></returns>
        private static string _ArrowLeft2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1656);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAFgAAABYA3MXpWAAAAtBJREFUOMvVlU9oVFcUxn937rz37pvMTKPRpNFYUrBRjDUtuNGWMboxKCqi2I3ipt34BxU0YP3fhWtdiOKqm1LaCqIbERUVKQ1Wk5hRkQom");
            sb.Append("mWTQNJOM42QyeTPvvetCU4IZaWLIwm9zuWfx4+M753CE1prpUGBaqEDw3YJYen7MB9Bj3tEagOMdCQZEc1lE2ZmiuKNbtq+cquMw2cKNckv+dPr4qvD325ZKRohNLQrN");
            sb.Append("Sgbzz5Ysqlz1y7mNrNtQh2cqkMb/R/FeFbzDOO7RzZsWG/t3LycftHnYDwURAGmIyYOFiDLkXCoLmY0H9n3L+nX1dPQFSLugKHKvfQCUGpkcWBMjk//9iwWVVceaY9TU");
            sb.Append("zeGPB5DXkE+/5OrFdrq6MhnC6oeJgQXgeD/iFI83ra4zDuyN0eOEOHUdAgakO7tpuREnP+w9JKyagOREwOXkCheVMht37ljG+g0NXGgVXHsEtiyQehyn50m3h2meJWTu");
            sb.Append("RmsQ4yIuAS668fkLqmqa96zgk7mVNP8G9xNQYeVIdPzJ8MtsCju0BSFuvu3BBME+diRi0efb/HwLWnvBBzI5jfBBGlbBk6ofOwTSgqANhhqHGT/HVvDrtrbe+IlDl3nx");
            sb.Append("9BmLaqEiAiMiTO03K1jTWDtHoe9T1AdBQKC041IL0oOylriee6bzTovf19ZKVblL9Sx4OmjRG15M09p6syJqnKTg3QaipfpfevM0YBi7tGl99+KfRKb7r3uExSs+nQ3t");
            sb.Append("CWhJVfHlsoXUzIvGcP0nwPKJgf8bu8AFlKrPprMdXX/HIdPPZ9UwkIW7PWWE5n1OaGZ5NYgrkwMDaJ3ENBqKnjibfNzlDyWTVM/00QI6UxJhR0EakcmDRyUDO7Rhbh14");
            sb.Append("nh4aSCSZYRdRFgwXBEhTfzgYQPArhlmXy3kP/k2kMH0HW0mQppga+I2eI+VXrpZnBlP5EcdxfQyjfZyHj+7mvQbfdgLABMetxQAAACV0RVh0Y3JlYXRlLWRhdGUAMjAw");
            sb.Append("OS0xMS0xNVQxNjowODo0NC0wNzowMHaWzkcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAy");
            sb.Append("MDEwLTAxLTExVDA5OjE5OjI1LTA3OjAwFJUwZQAAADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAA");
            sb.Append("JXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQ0LTA3OjAwKSe4cwAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJj");
            sb.Append("ZQBOdXZvbGGsTzXxAAAANHRFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuaWNvbi1raW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowLeft2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowLeft2_Reset()
        {
            _ArrowLeft2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowLeft2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowLeft2 = null;
        #endregion
        #region Image ArrowRight2
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku arrow-right-2.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu ArrowRight2_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property ArrowRight2, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRight2_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-right-2.png
		/// </remarks>
		public static System.Drawing.Image ArrowRight2_Cached
		{
			get
			{
				if (_ArrowRight2 == null) _ArrowRight2 = ArrowRight2;
				return _ArrowRight2;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku arrow-right-2.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image ArrowRight2_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRight2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRight2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-right-2.png
		/// </remarks>
		public static System.Drawing.Image ArrowRight2 { get { return _ImageCreateFrom(_ArrowRight2_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru arrow-right-2.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRight2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRight2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\arrow-right-2.png
		/// </remarks>
		public static System.Drawing.Image ArrowRight2_FromFile { get { return _ImageCreateFrom(_ArrowRight2_string, "arrow-right-2.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRight2
		/// </summary>
		/// <returns></returns>
		private static string _ArrowRight2_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1676);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAFgAAABYA3MXpWAAAAuFJREFUOMu11UtoXFUcx/HvOffcO3cmM5NMMomJSaBPgqGlLQHbqOADkoHY2FVpwY1IQRAXEl0kOxGb2GWN2IcYlKABFxpcZCMKIpaSmLTU");
			sb.Append("ptoumqqZ2MaZvOd15849XTSgZKZNYswPDhz+iw+Hc/hxhNaa7YjcFhVQawei5eJIuV+1Z1acrKNFP2XBHiwblP/Bsmww/WCuzlb3+mJ4nROnndgrJw8aH55uK6sK2t2k");
			sb.Append("8j8BFVu/Cq1xTZNYx26Gzr1Ey4Hap1hwbuPxImIrsJCiIA0mE2BURTjf9zwvH38iIrPeME6hd6N4Mez3p8Ym7jE17XA9CdfmfHS9doD3ug6pcMDXQ9q9BET/A+w7MT46");
			sb.Append("k+zr/ZHJGwtMzsKXVwSHW+v5+J2DNO+pbGXF+xVPt28OhhGCdvN0fHnis4FRxsbi3E7CB9/DkgzxUXcTx16ojpKTI+R178NgsbYg4unPwfCBGQBpvQ/GW/V7G1TN7p2k");
			sb.Append("C4rn9sLJJ+Hb0SX6h5dZdtVlgv5OfSGceDT8zBersB+sABi+I2jja7s8XFuxYxeJtMX+Bng7BrlMnjPDaW7elff0J6HafztFBSHaBGL16aUET8wZmqwQksWUxhNwLQ5n");
			sb.Append("f4DOfQahkAWzwreWKYaF+Acu8KYS9MWOVNpx6rg6o6gqh8ejMLfo8O5QnnzBuIUlO9eHHyRI3vuqIuxre7a1nplchF/+hJoIVJdrErNZ7v7tao35KaZ8tRRQ4sQcwvW+");
			sb.Append("qasLNTTta2A8EWA6CXU1ELIKTP+RZXFFr2CaryPEIGgo0ZpiWPOdXRmJBHc08nPcJJWFxscAN8edOzkc1/gNU3UAUzwixbA0K1Qwwu/zJkJDfdQjs5QhOed6WqpBlDwF");
			sb.Append("uKyTYliZOuVIURaCkOUyP5smlfEyKPUGiIH1wIfDhoVtS2ydI/FXirxn3ECpoyCmNopCqUor36iTznrJRCqX94wBDLkfzaZQKNG8/yvb9ufdByIeBMbxq+GSAAAAJXRF");
			sb.Append("WHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQ0LTA3OjAwdpbORwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAl");
			sb.Append("dEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTk6MjYtMDc6MDAlfSr4AAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2Vz");
			sb.Append("L0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDApJ7hzAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5");
			sb.Append("ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS92PbRSAAAA");
			sb.Append("AElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property ArrowRight2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void ArrowRight2_Reset()
		{
			_ArrowRight2 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití ArrowRight2_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _ArrowRight2 = null;
		#endregion
		#region Image DialogOkApply3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-apply-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu DialogOkApply3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property DialogOkApply3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogOkApply3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3_Cached
		{
			get
			{
				if (_DialogOkApply3 == null) _DialogOkApply3 = DialogOkApply3;
				return _DialogOkApply3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-apply-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image DialogOkApply3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogOkApply3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogOkApply3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3 { get { return _ImageCreateFrom(_DialogOkApply3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-ok-apply-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogOkApply3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogOkApply3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-ok-apply-3.png
		/// </remarks>
		public static System.Drawing.Image DialogOkApply3_FromFile { get { return _ImageCreateFrom(_DialogOkApply3_string, "dialog-ok-apply-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru DialogOkApply3
		/// </summary>
		/// <returns></returns>
		private static string _DialogOkApply3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1936);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAFgAAABYA3MXpWAAAA6RJREFUOMvVlV1MnEUUht/55vvb/WDFArbIjxYqaoOBxJiuUmiJCbGW+JvWtDeNjXpl1BiN6YVXNTFpGr3oRWOUGqKxSY1rA9QoJbFRNCSg");
			sb.Append("0C40QG3ZhfJbYBEo7M43M8eLTZfY0pDU9MIzeS/OzZMz7zlnhhER7kYYd4UKwASA7MOFICKY2gIXLixpgwsHWgHK9KG4AFkSPhOApUCOhA8BWBK+4YNMHzDUbjvL+dIw");
			sb.Append("2NLKgZXS/1wxEQFSfXT/ffmRPdXh/A1ZOQ9kKr7TkFIXwEbkiYrybQe2VbLm/iuYvvp3yx17zAD4Uj0P1+p5aXtV+Ej9DtY9PIW2jsEL2qe9mYqJKIc02QCm1726JiwL");
			sb.Append("9Ulecc6bB3c+ar1SVoqm/sv46uzFUeazemYxkQG7Aed3ZSBfJtSzHOi6HVQpKhAmRbZWbAq/XVeBnbm5+GLwCo639M+zZV3PPUxpppGxIuR5W2qqS/Jsz/5BSV0GdivU");
			sb.Append("9/ULRjbvqa/dHD68qxpP5RbgVGwUn7f+lWTzbJ/N7QFT2TB9dxWcGJPdDwY9vFz/UJ606JySVLx6dUBI/Vl2kf3ta889tvGDmlqUBjbgzMgIjkeGlZjQBz3H/tHRHoKp");
			sb.Append("HGQt5a2C6bpxrLM7QXsrwmioKy9KMtWuJVwlqTjFVeeWqtAb770YNvc/HIZLDn6diqGxJUaLcfWxa/OT6d2l9GHpLO0x3O8vXVweOx+bKzpUtweJpabyzrb5PsszQrV1");
			sb.Append("G/NfffJxFAcKkRSLGFyOobE1hqk+1egG+YeKyTX7YQCAqa2kueCcbO6KgmkH79Q2oGpHVllDQ2H+WzV12GSWYEEsYjgZx9ftMVzt0r8EOX99rV78C2z4NhzlfhqLJlfO");
			sb.Append("xjpQ4Bbi3aefwb7K7TB8DwkxhzExgm9+HsbQOR11ie9ebwMyYBPWhD8RaP8tGsd4KgaP3YOUUJgXc5jV42jujKOvDZN2iu8Cx9J68562QjgwfQe2cI9e6hU6OjeIWTGJ");
			sb.Append("hJjBHMbxU08cva18wb5uNTATYwABIIClRTcp0zwzmZ49U6Fj5bI90DMwvTVUySGRQtfANXR/56T4LN/Pgqk/FDEw4mkpDqZM8DW8ToOVdSPXbJGdGP5THd38yChmrhF6");
			sb.Append("T2dpY9J53wjKM/ADIBkAkrT6aIBAt7PC0FZGFqym1FB2oveCxPnTIaih0BHToWM3SGytim/SmmCD8RljwT0xGSlJ+tF7T5k2Hbp1rNb3mP3v/rx/ADXVvTe8CpXxAAAA");
			sb.Append("JXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQ0LTA3OjAwdpbORwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEA");
			sb.Append("AAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTk6MjgtMDc6MDB1QlGlAAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vu");
			sb.Append("c2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDApJ7hzAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJl");
			sb.Append("YWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS92PbRS");
			sb.Append("AAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property DialogOkApply3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void DialogOkApply3_Reset()
		{
			_DialogOkApply3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití DialogOkApply3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _DialogOkApply3 = null;
		#endregion
		#region Image DialogCancel3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu DialogCancel3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property DialogCancel3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogCancel3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3_Cached
		{
			get
			{
				if (_DialogCancel3 == null) _DialogCancel3 = DialogCancel3;
				return _DialogCancel3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image DialogCancel3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3 { get { return _ImageCreateFrom(_DialogCancel3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru dialog-cancel-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\dialog-cancel-3.png
		/// </remarks>
		public static System.Drawing.Image DialogCancel3_FromFile { get { return _ImageCreateFrom(_DialogCancel3_string, "dialog-cancel-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru DialogCancel3
		/// </summary>
		/// <returns></returns>
		private static string _DialogCancel3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(2392);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAFgAAABYA3MXpWAAABPlJREFUOMu1lW1oVWUcwH/Pc8655+zu3ut2tbyrzeXQzcLsZqjLgmWoSBsGmZEERoSub5ZCZBDRtwqiD4YQBpb0BnPQyJZbSq8wqV1Mym6+");
			sb.Append("rG13W7uWc8217Z57nvM8fdi8zaKP/T//nx8//i/PXxhj+D/CBnixuppQKUIpH6pNJt8iDPXwxMROV+tOyxikMVhaYwFCa66phGG4fnFl5Ueu65bnf/11rxOGb1rG0Doz");
			sb.Append("gwTAGGa03rK8quq9x6qqKh+tqFhYF422+0I88F9GvlKNqXj805Z16254sLk5uqy+/g3f93cwVwEbQAmx/ba6uiPbk0kv/vTTEIY8+NxzXqfvt/cFwU5P67b50KIxTUui");
			sb.Append("0Y83NjTEk089BVVVbEwkbGnb7/SfPr0IOCABqqurD+1Ipbz4k0/CmjXQ2Ejl88/T7HlevdZHivPMi7CuxraPbaqpiS9qbYXbb4eKCtyWFjY+8ohTu3r1K8BsKYTWOhQC");
			sb.Append("Jifh8mUYGEDedReJ/fu5v6zMW+b77UrKLUVYc5NS3U0LF8YqW1uR6TTkcrNvJifRxiC01iXw8ODgE20jI4XJd9+FY8egWIRcDvvOO1m0bx8bbNtbOj3dcZPvf3Wf5yVu");
			sb.Append("3LULZ/VqxMgITE9DNkuhq4vPP/wwyPX2PlMCO0J0XOzr29Zx+XJh6uhROHkStIaBAeyVK6nYu5dGYyL3+L6X3L2byDXTQgFz/jz+l1/ydVeX6stkWqWUhwCEMYaXUilQ");
			sb.Append("itCY7bcuXnxkSzTqVW7aBOk0FAoQizHV04P2feJNTTA1BbaNuXSJP3t76TlzRl346ac9jhAHhWWxKwhmpwIAIYgY03ZudHTKJJPtWzo6vMTVq9irVsH4OOXLl8/mjYyA");
			sb.Append("46DyeaYyGXqyWdXX37/blvLwvxZEzIcL0dl/5UpLVzz+yYbjx92FxSLOihUwPj6bY1kEuRwTp07x3cCA6s/ndzi2fRRjEMaUWDZAbGYGjMEIgRAC35jflW0bNTPDWEcH");
			sb.Append("bi6HcF0QAqMUM0NDCCCU0gitf3PmtlIC1uxQXG8sgEIYNtZUVXVttm0vHBriqlIE3d0U53IinoeTSFCeTNJYX+9I2z4+PDDwsAWdYh5L/mNNm5bU1nZvjkYTzoULBEr9");
			sb.Append("bQJYUiJcF2nbqDDETExwdzpddktDQ3sA2+ezSmA/CNbVLFt2rCWRiEezWQpKIQAzZ7HAsljgOFildggCpRBjY9yzfr1Xu3LlkQAeuA6swrDp5hUrupqTyZibyVAoFktQ");
			sb.Append("C4hHo/zseeoHywrKHQdbCIwxCCkJwhDyee7esMGrvuOO9nDOXAIsrqtr25pKLVhw6hTFeVAJlFVWctbzgj6tHx8Mw+YffL/geh6WlBitEVKigoBIPs+9W7d6qXT6UAns");
			sb.Append("eV40WiwS+v7sLzpnWp5K8aPrqgtTU60WvB8R4rPc9PS2H//4o1AWi2FZFsYYEILQ93EtCzcWKyuBR7PZ/d2FQqDWrsUWAhtwli4lE4mo8+Pjeyw4fK3bjhCdg2NjO78f");
			sb.Append("Hi7Y8TiOZSEBUVvLd998o4d6el4tgS04cC6TefyLMFQyncZpaOBbKdX50dHdljEHBdeHLUTb4KVL276/eLEgKypwa2o4c/q0PnfixLOE4QulOUYIXCk/+OXs2ZhesuR1");
			sb.Append("o5QeyuX22EIcRgj+eRUF4EBnfmTk0V4h3o7E495QNvuyA6+Vcv6vY/oXBuktNFQ4SdkAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDB2");
			sb.Append("ls5HAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToxOToyNy0wNzow");
			sb.Append("MIMKIUwAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0x");
			sb.Append("MS0xNVQxNjowODo0NC0wNzowMCknuHMAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAADXRFWHRTb3VyY2UATnV2b2xhrE818QAAADR0RVh0U291");
			sb.Append("cmNlX1VSTABodHRwOi8vd3d3Lmljb24ta2luZy5jb20vcHJvamVjdHMvbnV2b2xhL3Y9tFIAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property DialogCancel3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void DialogCancel3_Reset()
		{
			_DialogCancel3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití DialogCancel3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _DialogCancel3 = null;
		#endregion
		#region Image Documentnew5
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-new-5.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentnew5_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentnew5, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentnew5_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5_Cached
		{
			get
			{
				if (_Documentnew5 == null) _Documentnew5 = Documentnew5;
				return _Documentnew5;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-new-5.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentnew5_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentnew5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentnew5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5 { get { return _ImageCreateFrom(_Documentnew5_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-new-5.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentnew5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentnew5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-new-5.png
		/// </remarks>
		public static System.Drawing.Image Documentnew5_FromFile { get { return _ImageCreateFrom(_Documentnew5_string, "document-new-5.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentnew5
		/// </summary>
		/// <returns></returns>
		private static string _Documentnew5_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1876);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAFgAAABYA3MXpWAAAA3VJREFUOMu1lV1MHFUUx393Zndgd2lBATXd1gQ/a6Sx2mpIilS0JTGWRB8kqQ9+vOmbH1GjD33T6FN9MakvTZpommiUpNvEhkRILKK2CgVM");
			sb.Append("W8EsCAHdAuV72d2Ze48Ps7M7YAn1wZuc3JM7M7/7P+fce0aJCP/HiATOtsff+Pxw25NHq6sqlafNlrtJyBEF0YitBodHFi9duNiOZfUiIogIh949ncvLzQ8TMl1cOzM4");
			sb.Append("I07z253xlnfKihOxShX9D6GKlM0Ajg0Jx8Z2nIhtqTJYayM6nJtNwjfGB4WhxvjggmcQI0a24KwbRorgjdBgBiwLlPLtpsASmJTTEGwQPBRgtQBa++tbgsPKwkoDX2vI");
			sb.Append("a1ARmF6BQh6wtwBvDF2krNwI5D0oaPAEoqYYgfJtU3App1IGlSIwkNM+VGwwnr8mpvy9telRCs8h9Z6BrOtDiUBhLY8W0BLUwH/7hmAdDt2Ufc+DHEACVBxWRn9n6fjz");
			sb.Append("rJ3vhEooVMTAihsiiRunoqQ2VDhXQ8GC5YkxZru+4pbDHeTSI+zak2Zu7RKLi8+yo/cUb2bO1BzITP4bHD5aRsAtQj0NVhVc60mxq36I+e45FmbraWjZiTsCuVMf0NF6");
			sb.Append("gtYfl3aPdi5bVjj8QJ3W4AYF8vy8GgGjoa6tg7mlJA3N1VSmv8RIBfZoit0HUwyMPciH39/TD7YpKZ5ahhUPtim/MLqo2BRPgdgwO3yZ7J8jLEzVkD2R4rFjT6Bieaof");
			sb.Append("qmD+6yv0de7HSrqN9R4vhXqFD9Oshwa+6xa41vUJ9z9yO3c/k0BWm1DxBFZ9EnSe6J4aXnu0ByeWvfPvb5InS2BFqMmEocbfTNkREo3tTGX68S4v4oz9QO0Dh5DcdZST");
			sb.Append("pzC8yLcDe7HddHbfr0Nd1saToNkADTZxLepa24m3vYcnce564Sn+ONnHSv8QU58NUNMUx6u1SJ3dnipcXXuupNiybSvmQAJQdrlrlVJkQMVgrvML9jXOsDKdYHyikdu8");
			sb.Append("NLMLByj0rnL05fM8/PP1lsw5rBL4r4n03Kc9M3fcGnPIe7Ku2QTXmgpYXthJX/c5phtfJXnfPAejV5hM7qCbF7n3o9dpGP/uQhUYFfxM1d5XmonWvkUkUoGEb32xAEG+");
			sb.Append("og7K9ZDK7d7+zMW6s0d+afr4p4bx4zz9G9n5q8cGT79/RE+afwCOJ1BIlRV/kgAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjowODo0NC0wNzowMHaWzkcA");
			sb.Append("AAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjE5OjI3LTA3OjAwgwoh");
			sb.Append("TAAAADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1");
			sb.Append("VDE2OjA4OjQ0LTA3OjAwKSe4cwAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXxAAAANHRFWHRTb3VyY2Vf");
			sb.Append("VVJMAGh0dHA6Ly93d3cuaWNvbi1raW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentnew5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentnew5_Reset()
		{
			_Documentnew5 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentnew5_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentnew5 = null;
		#endregion
		#region Image Documentopen4
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-4.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentopen4_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentopen4, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentopen4_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4_Cached
		{
			get
			{
				if (_Documentopen4 == null) _Documentopen4 = Documentopen4;
				return _Documentopen4;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-4.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentopen4_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen4_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen4_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4 { get { return _ImageCreateFrom(_Documentopen4_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-open-4.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen4_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen4_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-4.png
		/// </remarks>
		public static System.Drawing.Image Documentopen4_FromFile { get { return _ImageCreateFrom(_Documentopen4_string, "document-open-4.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentopen4
		/// </summary>
		/// <returns></returns>
		private static string _Documentopen4_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1740);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
			sb.Append("EUlEQVQ4y52VTWhcVRTHf/e9N2+SsS2CZmEDUpQIRXDhQlqL+IHOQlyKIM80K3d17dKtiKtutC5ExKy6FoyCKKTWNviF3WgWtWQa0kxNOunMm/fuO/ccF5NOZ6ZRkx64");
			sb.Append("vHd43N/933P+716XZRn/FVUoC+dcbGbOOQfAnZe0lv7Rz8vn0zRtT85LALz38ezs7OG9wOsbrfpnn36Oc25sACwufnF86ZulFeApYOce8Nzc3O/OuccBmwSbGWtra5Rl");
			sb.Append("OcxDCKgqp08v0Ol0Hl35aeVC2ffPpGnaHwOLyPH5+XlCCJgZqgqAqvLBh+8TRRGXLl8aW/DkiRMAnDnzjjv3ycdPLl9YPovx9iTYRMS1Wi1EBFVFVTEznHOkaUrzlSZm");
			sb.Append("NlQN0G63ERGePXnKXfzxhzdUJsAhBFNVJyLDbd4ZAEmSsPT1V4QQhopffOElvPeDxIGqRhAxobgykYoQAr66CxYRcDG4mGbz1TG1o88kqWMW6Xrt5anvjl3z2eqquizL");
			sb.Append("aDQasrCwEF+80uL8L0IU3V3ZzIjcSD7R313+7u5ccM61L5978+iwxiEENm8rzz19jNdOPTGcMPDtv/t89FPuJX7vo29nsuwtG9ZYRMhLY2a6zman4PpWn4PEVC3m4cM1");
			sb.Append("ojjqTrqCXgWPPVAHg2SkHPsJNSh9IHJRZwiuqkHz8spxpFHHDJJ4/+BeIUynMd4LLmJ7zG4igdzDoUZtYJd9cIMaeRmQoEynNYq+B7g5qpgQAkU1aIcXvQegxu5fOci9");
			sb.Append("KGrjDun0SkztxqhiFRH63vDB6BaBXil40T0Be5ajjNm8lSOq62OKKxF8MLa7Fa2tPkH/HzYaO7WIrU5RWdDNIRjQvAzUazG3+oIcEApQVsZ2t/Q49/comG6hPPLQER5s");
			sb.Append("JByaOpjVACLn6PVKMbUtgGRxcTFpNpv250bJzU7B9z9fPTAUIJjS7eWp9LavEQ8U1/M8//LX1fbrVaOe3O4V94F1ZmZS7mwsXzn/7tXfdk+BGnAUmBktzX2EMrie/sqy");
			sb.Append("rEgAAa4DNxg/Uw4atguvAP4B8QDyvvsXDgUAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTBUMTk6Mzg6MjAtMDc6MDCAfY3xAAAAJXRFWHRkYXRlOmNyZWF0ZQAy");
			sb.Append("MDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo1NjozMS0wNzowMLA05WIAAAAydEVYdExpY2Vuc2UAaHR0");
			sb.Append("cDovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9QdWJsaWNfZG9tYWluP/3qzwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xMFQxOTozODoyMC0wNzowMN/M+8UAAAAZ");
			sb.Append("dEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAGXRFWHRTb3VyY2UAVGFuZ28gSWNvbiBMaWJyYXJ5VM/tggAAADp0RVh0U291cmNlX1VSTABodHRwOi8v");
			sb.Append("dGFuZ28uZnJlZWRlc2t0b3Aub3JnL1RhbmdvX0ljb25fTGlicmFyebzIrdYAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentopen4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentopen4_Reset()
		{
			_Documentopen4 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentopen4_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentopen4 = null;
		#endregion
		#region Image Documentopen5
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-5.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentopen5_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentopen5, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentopen5_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5_Cached
		{
			get
			{
				if (_Documentopen5 == null) _Documentopen5 = Documentopen5;
				return _Documentopen5;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-open-5.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentopen5_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5 { get { return _ImageCreateFrom(_Documentopen5_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-open-5.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentopen5_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentopen5_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-open-5.png
		/// </remarks>
		public static System.Drawing.Image Documentopen5_FromFile { get { return _ImageCreateFrom(_Documentopen5_string, "document-open-5.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentopen5
		/// </summary>
		/// <returns></returns>
		private static string _Documentopen5_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1704);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
			sb.Append("AAAAFgAAABYA3MXpWAAAAvZJREFUOMvVlTtsFEcYx3+zu/h8uQNjngIUx7JMMEkFDXRUSaQU0CRKl0iIDhEJIUo6GpMignSR4poGBUspeAjxkEikoBCETBTx9FnGNj6f");
			sb.Append("fbe+vb19zHwUs8fZdyBEJIp80mhmdke/+c//+2ZXiQjvI5z3QgW8d1n81deH/hoa2r0jiSPd+U6h8HI97g+jozdF5BslIqjPfzv46eDa8TcBH/xx5zATJy+cPXeu9v2x");
			sb.Append("Y6SAdIGtyp07B0qPHk0NWsXKGZ/4+cBrob9cLXPk/tIYwyc2BVGKr6FWBUz32bf1Q6JNtMqKp77t55faa2MN3322mS3F/Rw8zhl/eZInc5CE4LogIjiOQgSSFJqATjqS");
			sb.Append("Vwtta8SQGtBij/dnCUaGt1C9/AWxgReLMF2GmQWYrSiel+F52Qpa9CGVjuQtBLa/dneGS5PbO87pAHn2bv2S2yUIm3bTlXFgEPo/aFv0CnynBH5lhtHz88ivneBszd/w");
			sb.Append("0cfQDO1ecVOIQk2hz+On8algz8hAAZSzCjwxC2Hm7+8lcBXEBnTWEgPVClCFoAHKg2pZszgbsWOXR37rQGFdHoxhNThOIcmqs9YEz4FIW79TbROZaIVZURBRLNQDQyLg");
			sb.Append("CBRdyFLTBi83IWracSOx4CQDJxk45/WCgXwP4EIhD31FRSEHxV5LdB0vtwpcjyCO7dgPbcVrk4ENpClE7ofcvf6YhenH4MHCVMT8s5Chfeu59Q/8+O3Rytzc5PUuxUnU");
			sb.Append("tgKVlV0LnKl2Ng6zYf0wsgYCp4G7VKPvk22ENfDnnp4CrnQp1pniSgNUplhLpjq14NYcbWs+0hAk3Vf8FbiRgkkzK2Lrl1kJ1u2Lk2r7vpXcSIO4bwCHdY0EGpplpir2");
			sb.Append("mTFgxPZpNm/Z4+TAD1wakUu5Cml13rBCuAXXHh72n2wfA6B3MxdvhLw11jjwIoTpiGe3p+He6QtAHYgB7GdTqXXACLALKL6d+tpYBh4C/4qI3wI7GbAP6PmP4BioAXUR");
			sb.Append("Mep/9897CWpxkhrc+I5MAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQ0LTA3OjAwdpbORwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQy");
			sb.Append("MzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTk6MjUtMDc6MDAUlTBlAAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2");
			sb.Append("ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDApJ7hzAAAAGXRFWHRTb2Z0");
			sb.Append("d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3By");
			sb.Append("b2plY3RzL251dm9sYS92PbRSAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentopen5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentopen5_Reset()
		{
			_Documentopen5 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentopen5_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentopen5 = null;
		#endregion
		#region Image Documentpreview
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-preview.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentpreview_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentpreview, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentpreview_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview_Cached
		{
			get
			{
				if (_Documentpreview == null) _Documentpreview = Documentpreview;
				return _Documentpreview;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-preview.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentpreview_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentpreview_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentpreview_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview { get { return _ImageCreateFrom(_Documentpreview_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-preview.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentpreview_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentpreview_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-preview.png
		/// </remarks>
		public static System.Drawing.Image Documentpreview_FromFile { get { return _ImageCreateFrom(_Documentpreview_string, "document-preview.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentpreview
		/// </summary>
		/// <returns></returns>
		private static string _Documentpreview_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(2076);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
			sb.Append("8UlEQVQ4y7WVXWhURxiGn5k9v1l1VxNCbdAo2j9ji9I2URoNTWm9kUa8CdQELBREKEhbrUSKl4HcedGbgqaCd61FY6FFCk2QVF3RtVZpU0hI2pjiuptNsuvJ2d2zO9OL");
			sb.Append("zYZoTEop/eAwnHPgmW/ed94ZobXm/ygB1AMb/iNnTGv9x8IPBlA/fn9iQEqBEJLyKJBSAlAqlTBNEwEgxPy4sFZHoy3AIrCQsgIsj3d+voOQEsMweJBIUltbA0rhOA4N");
			sb.Append("DVvm1voY/PGZ5sBIWe5wcnKSu3fvkfEV3/RPkUhnMWyTUnGUZ6sj7GteSTKVYkdTI1Xh8LLazIElQgh+GhxkYtrhdN8wDVuf571Duwlsk3BIEo8N83nfEPt2RvEe/Uhb");
			sb.Append("27vlrpcwfx58qe8SgbY43TdC695dNO1+kfp1URJKUG9q3OoIW7dt5NuvrlD/TJj+gQHeam1dpHelZFkuQTo9yXfXZ3nu5RdoeH0T1iqHhyUohiRDBcAxqK5bw669O7jy");
			sb.Append("e47x8XHK3silwUGhAAjG/srw2puvYEUc3BUWkSoTx5JEXJPVqxyMlQ4162oIqlwE5d0jlujYAHiYTGLZFoo87kob1zVxrBAuiogRAq0JFEg7RC5ssWJNFMOcXhI6D66r");
			sb.Append("qyOfy7N+bYRQSOLYBk5IUmUI7LJYFKRAobFsg/U1Ln7CXxYsAUzTRGvNG9vWks8HgMAICdw5uBsS2FIQEqCUYmPE/Ecp5s3bsuUlNlTPkLk3TDabo6hACoEjwTHKiStq");
			sb.Append("gZlOYj26z86dO5bdx7ISm9bWVqbSU+xrDBNNJUmkfdKBIluCTKBJ5QLcdJINxRSbNm9mZmaGIAiWN6+ypIPvH+T81+dZvWaG9XmbByMlJkwLVypWFWZJTYwy0N+PbVsc");
			sb.Append("+ehjrl69yvbt2wEWpUQALZ7nDQgpkXOHz8jICLHYDbxZn/KxqolGIjQ1NZLJZDh79iy+73O86wQT98dLnx479nYsFut/Et7ieZ72fV/n83ldKBR0EAS6WCzqYrGoS6WS");
			sb.Append("VkpppZSOx+NaKaV939fd3d26o6ND34zH9djY2KOTJ0++qrWm8pRjI8RTo7lQP6UU2WwWAMuyaGnZHXie98OXZ87w629D4U+OHo11d3e/s8g88QToSbhSinw+j9aaGzdi");
			sb.Append("QVfXibYLFy7smZ6e/iJ+6yYXL14MHT58+Puenp7OeY1nZ2cHKrmvgCqGVt5zuRyDg4M4jp07cuTDPfH4L1cqk3d2dvY0Nzcfy+Vyor29Xff29h6ST3P0aaW1JpFITBw4");
			sb.Append("0LFrIRTg3Llzx69du/ZZbW1t6dSpUynf96//2zvvT6316FI/9+/f/4HnebcvX758629kMajwAzXbkAAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNzowMzow");
			sb.Append("NS0wNzowMHHd6XsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjU6NDQtMDc6MDCGDgxlAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjI1");
			sb.Append("OjQ0LTA3OjAw91O02QAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNv");
			sb.Append("bW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDMtMTlUMTA6NTI6NDQtMDY6MDDh+tI/AAAAGXRFWHRTb2Z0d2Fy");
			sb.Append("ZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABN0RVh0U291cmNlAE94eWdlbiBJY29uc+wYrugAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5veHlnZW4taWNvbnMu");
			sb.Append("b3JnL+83qssAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentpreview_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentpreview_Reset()
		{
			_Documentpreview = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentpreview_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentpreview = null;
		#endregion
		#region Image Documentproperties3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-properties-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentproperties3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentproperties3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentproperties3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3_Cached
		{
			get
			{
				if (_Documentproperties3 == null) _Documentproperties3 = Documentproperties3;
				return _Documentproperties3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-properties-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentproperties3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentproperties3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentproperties3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3 { get { return _ImageCreateFrom(_Documentproperties3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-properties-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentproperties3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentproperties3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-properties-3.png
		/// </remarks>
		public static System.Drawing.Image Documentproperties3_FromFile { get { return _ImageCreateFrom(_Documentproperties3_string, "document-properties-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentproperties3
		/// </summary>
		/// <returns></returns>
		private static string _Documentproperties3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1404);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
			sb.Append("O0lEQVQ4y7WUz2saURDHP7Orp7oeREyCp9xWE0iiFjVHIeTs39B7rqUQe2ibYtN7Lp685m/wIiTYHwhBMAYvgbaHxV0pNCk9lPX1kOx2zcYopP3CsDPvLZ+ZeW924T9J");
			sb.Append("PKd+ePAKqD0GppR6/eL5/supxfrhgXqs6ocHyuNF7ma9vLxE13WUUogIIjdNBX0vDlRKOp2e4oTAQUC/3w9B7mpzcxOlVGj9QfD6+jqRyN9XXNediu+rfi5YROj1enMv");
			sb.Append("bGtrC03TFgNrmoZSio2NDQCi0ejcBHPBn7ufKBe3ERHOzs6m9hqNhu9Xq1WSySTlchnXdUPgUA/FpyVWVlYQEXK53JTVajVSqRTLy8t0Oh2KxeLMMw6BRQTLshARhsMh");
			sb.Append("w+GQvb09Tk5OuL6+Zmdnh/F4zHg89qfmvjO+F+yZaZqYpkkikaDVahGPx2m1WiSTSd80TVus4mBr3kV61mg00HXdj4+OjrAsa7GKP3zs+NDBYMD5+TmVSgXHcbBtG9u2");
			sb.Append("GY1GjEYjrq6uOD4+xnGc+VNRLm2TSqVwHAfTNAHIZrNUKhW/E8uyaDabGIZBPB6n3W6zurr6MFhEsG0bEeHi4oJZKpVKnJ6ekk6nMQxjfsVBZTKZ0MfhXaymaRQKBbrd");
			sb.Append("LrFYbDGw1/JgMJiZNJ/Pk0gk2N3dXewnFNTa2trUZHh+8KmUWgy8tLTEv5APnkwmb969f7v/GNjXL9+e+cc5I1kMMG4tBjzhZuZ1QAG/gV/Ad+AH8PM2dm/3+QMOtPXa");
			sb.Append("bbq1vwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xMFQxOTozODoyMC0wNzowMIB9jfEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6");
			sb.Append("MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA4OjU2OjMyLTA3OjAwgdz//wAAADJ0RVh0TGljZW5zZQBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93");
			sb.Append("aWtpL1B1YmxpY19kb21haW4//erPAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTEwVDE5OjM4OjIwLTA3OjAw38z7xQAAABl0RVh0U291cmNlAFRhbmdvIEljb24g");
			sb.Append("TGlicmFyeVTP7YIAAAA6dEVYdFNvdXJjZV9VUkwAaHR0cDovL3RhbmdvLmZyZWVkZXNrdG9wLm9yZy9UYW5nb19JY29uX0xpYnJhcnm8yK3WAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentproperties3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentproperties3_Reset()
		{
			_Documentproperties3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentproperties3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentproperties3 = null;
		#endregion
		#region Image Documentsave3
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentsave3_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentsave3, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentsave3_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3_Cached
		{
			get
			{
				if (_Documentsave3 == null) _Documentsave3 = Documentsave3;
				return _Documentsave3;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentsave3_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsave3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsave3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3 { get { return _ImageCreateFrom(_Documentsave3_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-save-3.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsave3_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsave3_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-3.png
		/// </remarks>
		public static System.Drawing.Image Documentsave3_FromFile { get { return _ImageCreateFrom(_Documentsave3_string, "document-save-3.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentsave3
		/// </summary>
		/// <returns></returns>
		private static string _Documentsave3_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1664);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
			sb.Append("vUlEQVQ4y7WVS4scVRiGn1Nd3ThCxo1uZjLJyBAnYraieFmr6O8w4EbGeAHvxE1AmOAvUH/GCP4CITuRoScMaGwkYE/ssrsu57u4qJrqqmmCAyFn0d/pbs5TD+93zqng");
			sb.Append("7jyOkQK89cabx/P5fDsZJLx/4xOGgwS6D0wCEAgBAgGAUBdCCJRRuP3tLUyNnZ2de9//+MNWCrDIF9t7e3sc3b3Li6+8zlNPPsEpNpzWQAdeA0Oo6z/znKPffkVVOfjp");
			sb.Append("4GJrbGbs395n97ldoghJCHQDaphngPU8CRDFGI/HqCpmvozC3RERzIwkBIbDhINfjs6V5dsvXcFxzAwzw93oGV/dvYq7E5LAcBB45+UrPYA7OF5Xr6u5U0ZB1VDV2lit");
			sb.Append("b2xmhBBQNfJK+PnO8bmMX7u2hZg3MRjm3jdW1RpsRl4Kr76wtbRtPmvrWt8a86JaGpsZbg8xFnWKKnJn/Ne5jK9tP9OC3R3rZuxmmCpAa/z8padXIN5ItJk3xlHr9e7e");
			sb.Append("NzZ3tPkhRqWZEtoYThvYgXYbCUgj1svYrY4C4OaH750rgocN7+5j82UUjzqs17yO8aOOlQMiIu2fX39zk/X19f81u/7udbJshohw6WK9PbV7QFSVGGO7aDqd8vmnn1FV");
			sb.Append("FWtra3zx1ZdnrOorYHNjg/v3Ux6cnLTrVaUPlg7Y3cnnc0SksxNqWIwREUFE0BjBHceRGBkMBmjTqxpsSuxE4e6IKqJKqCoWi8UKVEQoY2xvtCjCxuYmv9/7o9M8NSvy");
			sb.Append("PEnTFICyLImxIi8KRjoiy7IVqIiQFzllWdTfYySbzfrGSRh88Pd0ur9+4UKSpilZlnHjo4+pYoWZMZvNVqAxRhb/zinyglhVxNGIyWTSB4+Pj7579vJlpg9O9nGSw8ND");
			sb.Append("RqPR8vw3d+3ZLfnnZEJVlQDkeV4Dh+kcIDyul+l/pLtQlw2zexsAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDM6MDUtMDc6MDBx3el7AAAAJXRFWHRk");
			sb.Append("YXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNTo0NS0wNzowMFEkv20AAABndEVY");
			sb.Append("dExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9M");
			sb.Append("R1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjQ0LTA2OjAw4frSPwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vu");
			sb.Append("PBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentsave3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentsave3_Reset()
		{
			_Documentsave3 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentsave3_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentsave3 = null;
		#endregion
		#region Image Documentsaveall
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-all.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Documentsaveall_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Documentsaveall, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Documentsaveall_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall_Cached
		{
			get
			{
				if (_Documentsaveall == null) _Documentsaveall = Documentsaveall;
				return _Documentsaveall;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku document-save-all.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Documentsaveall_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsaveall_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsaveall_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall { get { return _ImageCreateFrom(_Documentsaveall_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru document-save-all.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Documentsaveall_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Documentsaveall_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\pic22\document-save-all.png
		/// </remarks>
		public static System.Drawing.Image Documentsaveall_FromFile { get { return _ImageCreateFrom(_Documentsaveall_string, "document-save-all.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Documentsaveall
		/// </summary>
		/// <returns></returns>
		private static string _Documentsaveall_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(1832);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
			sb.Append("OklEQVQ4y7WVz2sdVRTHP3fe60ts4ksLpkJNs5FAUlOQgm0RXCVudK2FbHTtDwSVakG0Ul0o+CeoIJUsBbvzx0oiSNO6UMSFWpMXowmpnaS+N5l77znHxcyb95I0iIUe");
			sb.Append("uAzMnfmc7/c7Z2acmXE3qr77xOzs7Jd5nk/Wkpp76dVzR+tJzUHZ3DkSHM45cODKFUK0D95/b1VU7PChQz9/fvny43vAMcRTZ58+20xv3uThk49wcLCxY98V/LIBuMTR");
			sb.Append("zrybnZl5IIqwsLAwclvFIXjm5+c5MT3NwOAgzeGDfHXt130tP3F6gmgdVlZWEBG8z3tRzMzMfJHn+fFaUuOV184360kdMBa//QZHYZskKdU6HOBj5JOPP+QjVSYmpxAR");
			sb.Append("RARV64Elyum5ubnm3xs3OHnqUYYHBnbaL7MsMgaXQDvz/Pj9VVSV765c4f7RUUQEU+2BQ/B8eukS0w9N02g0GBq65z/te4FWq4Wq4n1OjBFVRfrBqopEQVSoJY7BRsKT");
			sb.Append("Zyaqh9UtNUPViCJEUUQFFUXFiDFiZmg/2NSYmppCRQmiZD7y9bXr+yp+7MQ4ISoqWti37tEw26243AhRaGeeM8fHCopZMcUGimEGne2Aj1LZz7IOMUYARPrBZUdVxQel");
			sb.Append("7QI//La+r+LJ8fsIJbhrX0UKHXobxc45fAxEUR48ergruDiWas2MznZAVSqXaoaUYN0ZRW/jwsvP8X9LSvVFFGJ9D69n5U7KVPDeA1QNdmR8p6WqBO8ZPXKEVqvVBxat");
			sb.Append("Ol189x1wDlNjaHioCNn1pjlNU158/gXyPOfYWDE5ooYPoZxv6YGLj0dhJd3c5OKFt4kx8sZbb9JsNitojJF2u81Is0m6uVndIzEQvOePVgvpj0JiJJQXqSohhGpGvffE");
			sb.Append("GAkhEEKg0+kUL0Kf/aXlZftrfW0boF478EsFjirk3uOcQ1Ur0NbWVgXsrizLyPMcUcGHgJkhKrdWVldH+nMvvsfKZxs3Np4ZubdJmqacO/86PveoKmma7lGcdTrk3nOg");
			sb.Append("Vmd5aamyvwd8ffn3Z8fHjsW19fWnri4uDrskcapK37LuvzHPc/5cW2sD/LN1q5jZev2n3WB3t36m/wKP/XqgPXnXCwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0x");
			sb.Append("NVQxNzowMzowNS0wNzowMHHd6XsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjU6MjYtMDc6MDDX/hTLAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAx");
			sb.Append("LTExVDA5OjI1OjI2LTA3OjAwpqOsdwAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9j");
			sb.Append("cmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDMtMTlUMTA6NTI6NDQtMDY6MDDh+tI/AAAAGXRF");
			sb.Append("WHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABN0RVh0U291cmNlAE94eWdlbiBJY29uc+wYrugAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5veHln");
			sb.Append("ZW4taWNvbnMub3JnL+83qssAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Documentsaveall_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Documentsaveall_Reset()
		{
			_Documentsaveall = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Documentsaveall_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Documentsaveall = null;
		#endregion
        #region Image EditCopy
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-copy-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditCopy_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditCopy, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditCopy_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\22x22\actions\edit-copy-4.png
        /// </remarks>
        public static System.Drawing.Image EditCopy_Cached
        {
            get
            {
                if (_EditCopy == null) _EditCopy = EditCopy;
                return _EditCopy;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-copy-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditCopy_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditCopy_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditCopy_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\22x22\actions\edit-copy-4.png
        /// </remarks>
        public static System.Drawing.Image EditCopy { get { return _ImageCreateFrom(_EditCopy_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-copy-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditCopy_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditCopy_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\Icons\open_icon_library-standard\22x22\actions\edit-copy-4.png
        /// </remarks>
        public static System.Drawing.Image EditCopy_FromFile { get { return _ImageCreateFrom(_EditCopy_string, "edit-copy-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditCopy
        /// </summary>
        /// <returns></returns>
        private static string _EditCopy_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1456);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
            sb.Append("YklEQVQ4y5WVv08UQRTHv29m9+64guvuLzjYXf8PY4iVlYmlNQVEwUCsTQABlUSJIbG2sbUyMQSOEAlCwo/zrLEACiFibnfu5lkMu7dz7i3cNrPZ9+Yz3/edN7O0+Grh");
            sb.Append("IWvtY8CHhGg8mZj62C/uqCjynk3NDsrF6zdLXl7cEYIAABcXv28NHR6ugIhyc5y8IDNTFEWy5xsKhSKYmW8NbjZ/WtDdvZ1HV1d/agBSEAKRWeDl0lyWh0REny3w6OhI");
            sb.Append("8h6Gofy6/qU2/XSGmDm/bpuKxeX5sb6KVVvhWildXl4M5D8A7qu41Wphs75+a2Dsf47HJqhUZCUeHx/fCPX9IBs8MlKDYbFRvLWRxHzf7wuMx0zFzIxms5mAlVJWYqPR");
            sb.Append("yIR2UxhBcKcLjgPMjFotpTgMsbW9mSQGQWABbTCDiPIUG4+ZGUq1/1OcBpoxXtQHM1AsFm2w1jpRbMBAGLaw/a2eJHqel6jrVUwk4DgSSilorbvgTqdjlcVstw4z4+go");
            sb.Append("7go7r1wuo1KpAACq1WrCSoFjWKyCLLDnjVpAgCGEhJQSWmsIIRBXf715pgOGhoYSS4gIruv2bBaBqNsFruuCSBh1jpNsXn1rA1prOG6h8OPt6kpmkxJRslharRACRAJa");
            sb.Append("a7xfe5c1dc/J+wvMLbyY6fU/Lp+ZjQ1gjN29DwA4Oz/F7vcdMGE19z7u9d91HUhpphjVBCnNdX3y6wQHh/solcsrE+OTazeClVIolUrWkZWyq7rT0Tg7P8XB4T4g6PHE");
            sb.Append("+OQHAMi9ZxeX5z+12+0H6UORfhgMBrQA1TX43uz0879x7B/GlJ0K79XkLQAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xMFQxOTozODoyMC0wNzowMIB9jfEAAAAl");
            sb.Append("dEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA4OjU2OjMzLTA3OjAwJ6v0SwAA");
            sb.Append("ADJ0RVh0TGljZW5zZQBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1B1YmxpY19kb21haW4//erPAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTEwVDE5OjM4");
            sb.Append("OjIwLTA3OjAw38z7xQAAABl0RVh0U291cmNlAFRhbmdvIEljb24gTGlicmFyeVTP7YIAAAA6dEVYdFNvdXJjZV9VUkwAaHR0cDovL3RhbmdvLmZyZWVkZXNrdG9wLm9y");
            sb.Append("Zy9UYW5nb19JY29uX0xpYnJhcnm8yK3WAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditCopy_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditCopy_Reset()
        {
            _EditCopy = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditCopy_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditCopy = null;
        #endregion
        #region Image EditRename
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-rename.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRename_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRename, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRename_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-rename.png
        /// </remarks>
        public static System.Drawing.Image EditRename_Cached
        {
            get
            {
                if (_EditRename == null) _EditRename = EditRename;
                return _EditRename;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-rename.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRename_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRename_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRename_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-rename.png
        /// </remarks>
        public static System.Drawing.Image EditRename { get { return _ImageCreateFrom(_EditRename_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-rename.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRename_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRename_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-rename.png
        /// </remarks>
        public static System.Drawing.Image EditRename_FromFile { get { return _ImageCreateFrom(_EditRename_string, "edit-rename.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRename
        /// </summary>
        /// <returns></returns>
        private static string _EditRename_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1044);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAWAAAAFgDcxelYAAAA");
            sb.Append("7ElEQVQ4y+2VMW7CMBiFPxPTYm4QDzCFFTpH4hBA2wvQw+QMcAToLbzADRLm/wbFSAzp4kiu1AUlDEj8kvWeZOnTk/1kq7quucf07kJ9guPRRVHMgQ0w6YhZAl8a2OZ5");
            sb.Append("nllrO6GKyMQ5t9VAZq0lTVOMMa2g3vvGZrpxxhj23ztOp4pekjAejfl4/7wJHAfT8cZyseJ4PNB/6TObvrVK/3h1ezzwn8uLW1GW5c2t+BfsvWe5WLVKGfUYDVQiknV1");
            sb.Append("BCICUGlg7Zzr/K1Qzx+kGQ2glEqAV8AAg7AMMIx0GIJcgTPgg16CvwA/Qa+/svhEk6GJAFkAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDM6MDUtMDc6");
            sb.Append("MDBx3el7AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI1OjI1LTA3OjAw5hYOVgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNToyNS0w");
            sb.Append("NzowMJdLtuoAAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25z");
            sb.Append("Lm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjQ0LTA2OjAw4frSPwAAABl0RVh0U29mdHdhcmUAd3d3");
            sb.Append("Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/v");
            sb.Append("N6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRename_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRename_Reset()
        {
            _EditRename = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRename_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRename = null;
        #endregion
        #region Image EditRedo
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo_Cached
        {
            get
            {
                if (_EditRedo == null) _EditRedo = EditRedo;
                return _EditRedo;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo { get { return _ImageCreateFrom(_EditRedo_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo_FromFile { get { return _ImageCreateFrom(_EditRedo_string, "edit-redo-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1576);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
            sb.Append("u0lEQVQ4y62STWsTURSG33PnI62prf001oqNIqJUC1aFglipKG2VLAQRwZXI/AaX/gEX6i4bF/oLZuFHoaCgFBfFtgux1BZraZommEmbNM1MZu51M1NuhiS14oHDwH3P");
            sb.Append("fc57zxxgn5FI6iKR1A/uVcf2C/ZjK5HU2/87+MrYeQDINYL/q+M94dTociKpRwE8BPA8DN2qZNCq9eDTu3kA6DANx/orcCKpjwN4M673znuX+86WWspqoFUqLopODnaB");
            sb.Append("IxaL1YRTHehNAO9vjw5ju9nDZt6CI3bAGIFUgmPbYCrBSm+DGBCPxwN41DScUk1wIqmfALB0/dYwKqKErJXetcBdAaYQhGbDLgjYRQ7y/5IE10zDcdUahl9cvXTaJlAk");
            sb.Append("Y61DeNWiRzZUheDafPdMgnaYhuMCQC3whOiOIF1chqIwdLYfBsCgUQTCLxDwsMUXoEcJfbH+mjOuBYZGzVBIRVtXK7SNEqamF6v0axMXoTahLhSou8eElrZmbGRTYmp6");
            sb.Append("MQ/gjGk4ZBoOAYBCWkNoXbACFTFlQCx8znsA7pqG813WbW87gB6rBa07ClsUvLJQXQCRUynnW3h7JOga6kTYMQFYPjrrFTbLWQDA0ydI+3UUNHC2xXHTcFLyWSPHBICE");
            sb.Append("EF9+W3NjhMFgnxT5gmk4esiUCGWVGHRmxXU8ntxR2l3PEWo5kh9/pt334WooNf+rhF8kuyFfZD8/8NLJGyyTWsklLozGeXotN2Iti2QpC/Lr5WQSFLJjJeSYANDiW/61");
            sb.Append("f4TNZNLWg97OA6utA969I0Psx8pHnpJgAVDxgVwehwyuarA0yZcOxemlo7oaAUSMCrFBZke7yc3/EjZ3dyG8BpgoBA5cyDNjQ4+Uzp5z7A4x9AgPG3OvvNfcE7yLKzzW");
            sb.Append("S2qkSfC1VbEzO+O5QZPwqlCdlJvLIW9D1Sj+APIcOgD/R4P8AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTEwVDE5OjM4OjIwLTA3OjAwgH2N8QAAACV0RVh0ZGF0");
            sb.Append("ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDg6NTY6MzAtMDc6MDAWQ+7WAAAAMnRFWHRM");
            sb.Append("aWNlbnNlAGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUHVibGljX2RvbWFpbj/96s8AAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTBUMTk6Mzg6MjAtMDc6");
            sb.Append("MDDfzPvFAAAAGXRFWHRTb3VyY2UAVGFuZ28gSWNvbiBMaWJyYXJ5VM/tggAAADp0RVh0U291cmNlX1VSTABodHRwOi8vdGFuZ28uZnJlZWRlc2t0b3Aub3JnL1Rhbmdv");
            sb.Append("X0ljb25fTGlicmFyebzIrdYAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo_Reset()
        {
            _EditRedo = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo = null;
        #endregion
        #region Image EditRedo1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo.png
        /// </remarks>
        public static System.Drawing.Image EditRedo1_Cached
        {
            get
            {
                if (_EditRedo1 == null) _EditRedo1 = EditRedo1;
                return _EditRedo1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo.png
        /// </remarks>
        public static System.Drawing.Image EditRedo1 { get { return _ImageCreateFrom(_EditRedo1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo.png
        /// </remarks>
        public static System.Drawing.Image EditRedo1_FromFile { get { return _ImageCreateFrom(_EditRedo1_string, "edit-redo.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo1
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1732);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("eUlEQVQ4y62UX2hbVRzHv797z01ucnObtLOzarVdIwwdXRQFp4KM3VVXymB7mCi4B5la/7yKZooiPmjqgyAIguCTDBxOp8IU7ZKJSl/c3JxDR2rdTGxjdrumSW5uk917");
            sb.Append("z/HlpqRd4vKwH3zhcM6Pz/me3znnByEErqUdL0e2d5PXKgldBBEdGzvY80w3uc3oCgwgsCG68b1HXo29YyR1up5gHJh4Vh0eiL/AmHzESOqB6wZmTMG+HY+Ft8bvGVeY");
            sb.Append("/JOR1Hv/N7/dpJHUNSKaVBjbBYjbFTnIPO4gd/kUdt5rhGJaLPHj2cxpI6lvT6eqF9sxSAixZmLsleiLMkmvj8bvku8Y2hKOar3QQhoq9jzM6hxkKYDBvgQuFPL82MzR");
            sb.Append("iuO5Y+lU9WRHsJHUicnyB7fccNsTux/Yq5HkoGTl0HBrcLwVtBogkjDYl0CpUsPhzMcNl3vj6VT1RNtSyJL05tDAyP7d9+8JL5TOoda43LF+qqKDySFk/zlVByEL4Ne2");
            sb.Append("jo2kPhhQgtkD45OhYvl3XHFtxLSboSo61IAOJqlYsnK4VJ6FpvZhsG8rpn/5diWb/+Nn1/PG06mq3fbyiGgyEU8otYYJj3vYtPE+/Dk/y/PmrF0sFUVtxYo8NfEcWfUl");
            sb.Append("DMS24KuZL+yceeE7z+OPplNVp+OrYLL0YG+kh5WtIvqjcWROf9M4n8v+5XH+BoCzRPQbBLF+fTM+++ET21wuHvI4n0ynqgIdggGAEBiSJQIXQO7SRZzPZRc8zrelU9UK");
            sb.Append("AOw82IOKXcaXM0dWyrWld6ffqrx2rXfvfxBxziwXAU6w7GVIRH83of46Pv3+UH3ZWnqpG+gq2PX4icLiv/YVpw5JArgQdxpJPbaKFajXGtaTx9+uvN8NtMUxPiqUTNss");
            sb.Append("m1AVCSM33RqTJSkzujcUISLFqYs9mSnrKBEFfQWISCEiRkRt20LrB5lQGDs8OjysRTUd2fmFemHRnD4+VdnvG2jtahyAAOD5Y8+X2+St7paZsr5u1N3nz8zN2fnFgth0");
            sb.Append("Y79KEu3a/HBwBIAKIAxAAxDyFfSl+GIAFCJa69g/Etv2dDgR2SB/DqAfAgszH9YeskscAGTfSNOh66t17AJwhBBrm1ATDoDd/XhoJH/SMRdnXceHri8FX7eJA8ATPvCq");
            sb.Append("7uYfhXxY06XUAdysrRDrQFeBO0Wzdt3m/wcCgscSHuEXVgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNDo0MC0wNzowMBgWrX8AAAAldEVYdGRhdGU6");
            sb.Append("bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTM6MDQtMDc6MDDn5axlAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAv");
            sb.Append("bGoGqAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBHTk9NRS1Db2xvcnOqmUTiAAAAMXRFWHRTb3VyY2VfVVJMAGh0dHA6");
            sb.Append("Ly9jb2RlLmdvb2dsZS5jb20vcC9nbm9tZS1jb2xvcnMvUB216wAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo1_Reset()
        {
            _EditRedo1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo1 = null;
        #endregion
        #region Image EditRedo3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo3_Cached
        {
            get
            {
                if (_EditRedo3 == null) _EditRedo3 = EditRedo3;
                return _EditRedo3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo3 { get { return _ImageCreateFrom(_EditRedo3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo3_FromFile { get { return _ImageCreateFrom(_EditRedo3_string, "edit-redo-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo3
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1868);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("iklEQVQ4y62UbWwURRjH/8/O7u1ur69XW1qk0RZCoAat77UGAh+wLRUPTbCBpEaTXqtiTHwJflFi8IMRjcZEY9KzGGMwYoxwVYFqyltIQELEa7GkKKVNaTnao03vrned");
            sb.Append("vd0dP7BnruUq96FP8k8mk2d+85/nmRkIIXA7PdXhWp9NXrokZBe/bPlSa8syFwCyAxPBVV5U+ekze/U9Xr9KiwYGgB31H2qr7nzkFSazH7x+1bVoYIWp2L72Db1uZdMm");
            sb.Append("WWanvH616P/y5UyTXr/qJqJ2WZEbILBCk/NkGzb6Zg/gifu3acV5ZTU/ndt73utX1wd8fChj+YQQcyae7tTflIjtql1VL9fcvU4v1EvhVgtwzQpi2PgdMjTcoz+JkdAV");
            sb.Append("+5sTeyKmaWwM+Pi5BcFev0oSk75YvmRNy9bHXs1JsihGk0Ek7EkkKQ4igkTs5iIwVGubEJtO4PPDb3HLNhsDPn4sYymIsHtF+b3PbX6oVT8Z7sB1PjC3GcQgEQOTGIqU");
            sb.Append("Clgewh9DPVyQNQAgmNGx168uc8napZcb39fPTH+NmBlGpftRFCpLUaAshZsV41LsOC5EDqHEtRx1nhfwa3DfbN/w6bPCRmPAx+OZm0dor6tucE2Yf0MCQ/2Snfgn9Kf4");
            sb.Append("a7w3fm3yZxGLR9w7mj6gKWMEDxY24+DZjsTlUG+3sPFswMeTC94KidHjFcUrWYifR62nBYf7OvnFweCgsPEugF4AfRIx+YH8rdh/6pP46OTlfcJGe8DHBRaIm44F7irQ");
            sb.Append("SzFjluD69AguDgbHhI3agI9HnMYixqfw7cmPEjeiYx8fbOXv3O7epx7Ihal4CGXaakSMcZBEwyloKr7qeY+Ho2M7s4H+B7YtcWxovJ/nyiUodVdC2Kj2+tXCtLzZaGLq");
            sb.Append("+UAr/ywbaLrjzjMD3dHpeBhleVXYWNPsIQlHH35RySUixZgRW7rajANEpDpyEZFCRDIRZfwW0h9IU0n+su+3rX0tJ08rxtH+74zT/Ue6u9qNFsdA+q9mAxAALGdsAbCE");
            sb.Append("EOZ8x+hqMw6Fblx9qeO3XfEr4V6xYXWzK1/3NKzZzqoAaAByALgB6I5UR4ojmYiUWxw7R5I37Fbuyy+nH+/IrSidiF4d7Xmbr5sZBwAwx0jKoekofWwKIZJzwOlwAHLd");
            sb.Append("63LVYI81EQqKpAOdXwp73iZJpxziFnDaBuTAUi6lBcCWIyHmgTKCFyP+BZuism9f8UcPAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjEwLTA3OjAw");
            sb.Append("sUuSdgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MDk6MzEtMDc6");
            sb.Append("MDDt/ssoAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0x");
            sb.Append("MS0xNVQyMzowNDoxMC0wNzowMO765EIAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAF3RFWHRTb3VyY2UAR05PTUUgSWNvbiBUaGVtZcH5JmkA");
            sb.Append("AAAgdEVYdFNvdXJjZV9VUkwAaHR0cDovL2FydC5nbm9tZS5vcmcvMuSReQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo3_Reset()
        {
            _EditRedo3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo3 = null;
        #endregion
        #region Image EditRedo4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo4_Cached
        {
            get
            {
                if (_EditRedo4 == null) _EditRedo4 = EditRedo4;
                return _EditRedo4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo4 { get { return _ImageCreateFrom(_EditRedo4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-4.png
        /// </remarks>
        public static System.Drawing.Image EditRedo4_FromFile { get { return _ImageCreateFrom(_EditRedo4_string, "edit-redo-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo4
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1576);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
            sb.Append("u0lEQVQ4y62STWsTURSG33PnI62prf001oqNIqJUC1aFglipKG2VLAQRwZXI/AaX/gEX6i4bF/oLZuFHoaCgFBfFtgux1BZraZommEmbNM1MZu51M1NuhiS14oHDwH3P");
            sb.Append("fc57zxxgn5FI6iKR1A/uVcf2C/ZjK5HU2/87+MrYeQDINYL/q+M94dTociKpRwE8BPA8DN2qZNCq9eDTu3kA6DANx/orcCKpjwN4M673znuX+86WWspqoFUqLopODnaB");
            sb.Append("IxaL1YRTHehNAO9vjw5ju9nDZt6CI3bAGIFUgmPbYCrBSm+DGBCPxwN41DScUk1wIqmfALB0/dYwKqKErJXetcBdAaYQhGbDLgjYRQ7y/5IE10zDcdUahl9cvXTaJlAk");
            sb.Append("Y61DeNWiRzZUheDafPdMgnaYhuMCQC3whOiOIF1chqIwdLYfBsCgUQTCLxDwsMUXoEcJfbH+mjOuBYZGzVBIRVtXK7SNEqamF6v0axMXoTahLhSou8eElrZmbGRTYmp6");
            sb.Append("MQ/gjGk4ZBoOAYBCWkNoXbACFTFlQCx8znsA7pqG813WbW87gB6rBa07ClsUvLJQXQCRUynnW3h7JOga6kTYMQFYPjrrFTbLWQDA0ydI+3UUNHC2xXHTcFLyWSPHBICE");
            sb.Append("EF9+W3NjhMFgnxT5gmk4esiUCGWVGHRmxXU8ntxR2l3PEWo5kh9/pt334WooNf+rhF8kuyFfZD8/8NLJGyyTWsklLozGeXotN2Iti2QpC/Lr5WQSFLJjJeSYANDiW/61");
            sb.Append("f4TNZNLWg97OA6utA969I0Psx8pHnpJgAVDxgVwehwyuarA0yZcOxemlo7oaAUSMCrFBZke7yc3/EjZ3dyG8BpgoBA5cyDNjQ4+Uzp5z7A4x9AgPG3OvvNfcE7yLKzzW");
            sb.Append("S2qkSfC1VbEzO+O5QZPwqlCdlJvLIW9D1Sj+APIcOgD/R4P8AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTEwVDE5OjM4OjIwLTA3OjAwgH2N8QAAACV0RVh0ZGF0");
            sb.Append("ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDg6NTY6MzAtMDc6MDAWQ+7WAAAAMnRFWHRM");
            sb.Append("aWNlbnNlAGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUHVibGljX2RvbWFpbj/96s8AAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTBUMTk6Mzg6MjAtMDc6");
            sb.Append("MDDfzPvFAAAAGXRFWHRTb3VyY2UAVGFuZ28gSWNvbiBMaWJyYXJ5VM/tggAAADp0RVh0U291cmNlX1VSTABodHRwOi8vdGFuZ28uZnJlZWRlc2t0b3Aub3JnL1Rhbmdv");
            sb.Append("X0ljb25fTGlicmFyebzIrdYAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo4_Reset()
        {
            _EditRedo4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo4 = null;
        #endregion
        #region Image EditRedo5
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-5.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo5_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo5, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo5_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-5.png
        /// </remarks>
        public static System.Drawing.Image EditRedo5_Cached
        {
            get
            {
                if (_EditRedo5 == null) _EditRedo5 = EditRedo5;
                return _EditRedo5;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-5.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo5_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-5.png
        /// </remarks>
        public static System.Drawing.Image EditRedo5 { get { return _ImageCreateFrom(_EditRedo5_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo-5.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-redo-5.png
        /// </remarks>
        public static System.Drawing.Image EditRedo5_FromFile { get { return _ImageCreateFrom(_EditRedo5_string, "edit-redo-5.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo5
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo5_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1832);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAFgAAABYA3MXpWAAAA1VJREFUOMutlG1Mm1UUgJ++LS2sdC0gQt1w1eIIH65NLuDsj7GIM2bGjEWjiXMDE6NRM+k/v6IsWeYSdRHdNGaZoTNq4o/FJbCwmZBhcIwM");
            sb.Append("K8yyQlmEsrkNytryVSrEcv3xlghJiZNxknNzcnPuc84995yLlJI7FZcQu/ZWC/mYEPX/5au7Y6oqzrdri+mLPNSowPZZqOv0eidTOSr/Eww6I8/tf4fPPn2/pmC9qdcl");
            sb.Append("hGPVYJcQZpcQtetgOwvzEB+jRJRz9KuDtopCW++2FKXRSCnRaDQrAg3gtudlu2ueKrc8sLmIEmexmo9Go+rCHJ5jHr5t8Xri4F4szYpglxCOAqPh9Gt7HrFV7XgUNMpy");
            sb.Append("VRZtLWgUuju6OHKsufd6LFHX6fVeTgl+XAhHqVXT/t6b1ZZc671JkDYJ0f5rK8qyvfGxCIcPfzfR8cfU87pUmZbmL7QfeqPYYsychdifKkjRJQG6pC4GSNp/z5D7oJGt");
            sb.Append("T5ZYLjR2VC/L2CWEucCQ6D26N2rLteaB3gS6dEjLBEUPWh0oaSATKoyEamdoieXb+fzjXzl9duD4Jb//wLKMDeDeVxmx5RpjEJuDv9JUoCkHsqxgyYPoOEyFQatXg9xn");
            sb.Append("I5jI5+Ar56a7fCNufzB4CpjULe0A+/p5905HFNCrmxuKoGwbwTEtl34e4WrgNnvKp7FlA7o0KK3kfNc0H37wY6B/dPT1G6OjvwDzsGTy0qHuxfJxCwD6dKh4Gn80jyP7");
            sb.Append("2qYHhsPNkXi81ZSZWbPbnvEM9o3EbIKvv/idH075vu/s63sXGFn2WIt/xU4hema+XCdlk0nKcINs+qRWVm3Zcj7bbBZARvJWDVfOvCSHBw7J+heemHq4sLAeyEk5oMkD");
            sb.Append("m1y2SafRsACVu/E0BTlx8rfmCz7fy0Bo6YHWtkkuftQc6Bm++dbQtWs/AfEVwYCz6J445NvpDt3PiZMtKaFA4zet/ddHQ6GLoXB4UG2LFURKyQ4hGq4cMMuZwH75bNXW");
            sb.Append("GzlZWQ7uUpTk4txUtoEz7XNcvRU5Ho5G+9cEbACLsayCcy2Bm5cHBz2LLXPX4AWwdActDAyH21PUdfXgjZtznL6+CW7Pzq74yqsCA/R4bzE4NNS2FlBItpvPP/bqTDxu");
            sb.Append("BSbWCvwPBfJBRD8anFQAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDQtMDc6MDB2ls5HAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIz");
            sb.Append("OjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToxOToyMS0wNzowMODaFHYAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZl");
            sb.Append("Y29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xNVQxNjowODo0NC0wNzowMCknuHMAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAADXRFWHRTb3VyY2UATnV2b2xhrE818QAAADR0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lmljb24ta2luZy5jb20vcHJv");
            sb.Append("amVjdHMvbnV2b2xhL3Y9tFIAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo5_Reset()
        {
            _EditRedo5 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo5_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo5 = null;
        #endregion
        #region Image EditUndo
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo_Cached
        {
            get
            {
                if (_EditUndo == null) _EditUndo = EditUndo;
                return _EditUndo;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo { get { return _ImageCreateFrom(_EditUndo_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo_FromFile { get { return _ImageCreateFrom(_EditUndo_string, "edit-undo.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1720);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("cklEQVQ4y5WVX2gcVRTGv3NmdnZn66bJGldDWmppm9RgwdVq7W4C0oI+FPsgWEUwmz5VKIKgIJQi4kPxpa0+KIiIrGkb+1ChIApaDWnZphZBSDW16R9qS9kYwya7mzg7");
            sb.Append("szP3+NAZ3d2m6XjhYy7D4Xe/+c4ZLokIwq5CnrYC+Dmbk/q9ajk09At+AcAoAC1MfSjw+LD2lplYdZQ4YoQ1siy4kCc+d1T/JNG56b1N2w/HWDNUWLC+DNTUdP3k/auf");
            sb.Append("GVib3hNjjoVl3h1cyFNK07Ufuzfu2tDV87yhFkZAiZehGW1EsH//6Zhx1XPdUyLycTYn5aUY1DoVhTz1sh4ZW795b2dH16OaVx2BqCo4lgHH+uE6FTjWNOZuFWrFK997");
            sb.Append("otyDSql3s7lmUBO4kKcniHmsb+Cd+Ir2JLnVY4A4TS0hbgO0DrDRB6VW4NovR/4uz0x+ozz1SuMYtjbvEhMmSsVxG5wEuBMiboMcKG8WyrkMd+EkxP4O69I74h0PbdzB");
            sb.Append("Gn94rygM1virZPdT29Y+vtf0Fk9AOVPQYk+CjDQgJYg7DfFmoerXQaRDuA8XTn9Z8+q1x7I5ubTkuGVz4ihP7SzdOn986uwBi6PbwJH1YKMXEz8cUL+Nfbrwx6/nqnN/");
            sb.Append("lpUWTQMCsNxE18MbIqzxG8tORTYnCsDu8WGemTzz/us9W4ZMVjZce14cz8lY1WJPqcj7yjMPPrKmb7Op3BuIt0U1Ijx9t4yb1tZX1dtWpbh/8sxHlr14I3h9OZuTE8pT");
            sb.Append("/fN/TU+Vilcg4kLXaxCRVaHAAJAZVIfqtfKei2dHLKXcf+uzObEImFBeGSIOrOosiGgqNPg2XIZdp/YiRNkNTY4LkGF2obwKyqV5RykZXRZMRExEOhFFiMggomj/EE7N");
            sb.Append("VfDs4WHo27eQyUxfr0xGuxPtNqyFRczP2DVR8sEd40ZEQTM1/8DgyS0GZPQzOtSe5JfW9MbMuq1w/WJt0bHltf4hOdLkmG5TdV8RAAaAKIAYANNXHED8uQxSEU0GV6/T");
            sb.Append("zUrJwdULllWpyr6B3Tjuc/5z3AIOXLfuGYAC4J3+HN9qGnpEUL52E7sG9+M8ABdAXYIIRAT+nn2nJoD7AKwEkATQCSDVoAe6U0gdfBNpAAn/SyKByUB3/NK++yDjIGdq");
            sb.Append("KJHAuS8lS1ycFOYyDaL7PxfvP5pnmwfFXaK/AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI0OjQwLTA3OjAwGBatfwAAACV0RVh0ZGF0ZTptb2RpZnkA");
            sb.Append("MjAxMC0wMS0xMVQwOToxMjo1OS0wNzowMCEQqP8AAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvR1BMLzIuMC9sagaoAAAA");
            sb.Append("GXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABN0RVh0U291cmNlAEdOT01FLUNvbG9yc6qZROIAAAAxdEVYdFNvdXJjZV9VUkwAaHR0cDovL2NvZGUu");
            sb.Append("Z29vZ2xlLmNvbS9wL2dub21lLWNvbG9ycy9QHbXrAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo_Reset()
        {
            _EditUndo = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo = null;
        #endregion
        #region Image EditUndo1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo1_Cached
        {
            get
            {
                if (_EditUndo1 == null) _EditUndo1 = EditUndo1;
                return _EditUndo1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo1 { get { return _ImageCreateFrom(_EditUndo1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo.png
        /// </remarks>
        public static System.Drawing.Image EditUndo1_FromFile { get { return _ImageCreateFrom(_EditUndo1_string, "edit-undo.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo1
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1720);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("cklEQVQ4y5WVX2gcVRTGv3NmdnZn66bJGldDWmppm9RgwdVq7W4C0oI+FPsgWEUwmz5VKIKgIJQi4kPxpa0+KIiIrGkb+1ChIApaDWnZphZBSDW16R9qS9kYwya7mzg7");
            sb.Append("szP3+NAZ3d2m6XjhYy7D4Xe/+c4ZLokIwq5CnrYC+Dmbk/q9ajk09At+AcAoAC1MfSjw+LD2lplYdZQ4YoQ1siy4kCc+d1T/JNG56b1N2w/HWDNUWLC+DNTUdP3k/auf");
            sb.Append("GVib3hNjjoVl3h1cyFNK07Ufuzfu2tDV87yhFkZAiZehGW1EsH//6Zhx1XPdUyLycTYn5aUY1DoVhTz1sh4ZW795b2dH16OaVx2BqCo4lgHH+uE6FTjWNOZuFWrFK997");
            sb.Append("otyDSql3s7lmUBO4kKcniHmsb+Cd+Ir2JLnVY4A4TS0hbgO0DrDRB6VW4NovR/4uz0x+ozz1SuMYtjbvEhMmSsVxG5wEuBMiboMcKG8WyrkMd+EkxP4O69I74h0PbdzB");
            sb.Append("Gn94rygM1virZPdT29Y+vtf0Fk9AOVPQYk+CjDQgJYg7DfFmoerXQaRDuA8XTn9Z8+q1x7I5ubTkuGVz4ihP7SzdOn986uwBi6PbwJH1YKMXEz8cUL+Nfbrwx6/nqnN/");
            sb.Append("lpUWTQMCsNxE18MbIqzxG8tORTYnCsDu8WGemTzz/us9W4ZMVjZce14cz8lY1WJPqcj7yjMPPrKmb7Op3BuIt0U1Ijx9t4yb1tZX1dtWpbh/8sxHlr14I3h9OZuTE8pT");
            sb.Append("/fN/TU+Vilcg4kLXaxCRVaHAAJAZVIfqtfKei2dHLKXcf+uzObEImFBeGSIOrOosiGgqNPg2XIZdp/YiRNkNTY4LkGF2obwKyqV5RykZXRZMRExEOhFFiMggomj/EE7N");
            sb.Append("VfDs4WHo27eQyUxfr0xGuxPtNqyFRczP2DVR8sEd40ZEQTM1/8DgyS0GZPQzOtSe5JfW9MbMuq1w/WJt0bHltf4hOdLkmG5TdV8RAAaAKIAYANNXHED8uQxSEU0GV6/T");
            sb.Append("zUrJwdULllWpyr6B3Tjuc/5z3AIOXLfuGYAC4J3+HN9qGnpEUL52E7sG9+M8ABdAXYIIRAT+nn2nJoD7AKwEkATQCSDVoAe6U0gdfBNpAAn/SyKByUB3/NK++yDjIGdq");
            sb.Append("KJHAuS8lS1ycFOYyDaL7PxfvP5pnmwfFXaK/AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI0OjQwLTA3OjAwGBatfwAAACV0RVh0ZGF0ZTptb2RpZnkA");
            sb.Append("MjAxMC0wMS0xMVQwOToxMjo1OS0wNzowMCEQqP8AAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvR1BMLzIuMC9sagaoAAAA");
            sb.Append("GXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABN0RVh0U291cmNlAEdOT01FLUNvbG9yc6qZROIAAAAxdEVYdFNvdXJjZV9VUkwAaHR0cDovL2NvZGUu");
            sb.Append("Z29vZ2xlLmNvbS9wL2dub21lLWNvbG9ycy9QHbXrAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo1_Reset()
        {
            _EditUndo1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo1 = null;
        #endregion
        #region Image EditUndo3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo3_Cached
        {
            get
            {
                if (_EditUndo3 == null) _EditUndo3 = EditUndo3;
                return _EditUndo3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo3 { get { return _ImageCreateFrom(_EditUndo3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo3_FromFile { get { return _ImageCreateFrom(_EditUndo3_string, "edit-undo-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo3
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1816);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("Y0lEQVQ4y5WVa2gcZRSGnzO3zGy3m4tJQJM2FdJYK2pjRUi2LZIfhoL0h1AF0WylUEQsFBXEUFD6oyLaoCCCUoQQSylFRfCCtDZG3IhBpQ2aGtNWaxMVaS7bXHZ3Zuf7");
            sb.Append("/JHdsombdHvgMB8fh4d33nPOjGitKTeSvdIG/BBP6OBGtUb5UOMRoB8wy6kvCzzYZ7/gxTYcE7GdcoWsCk72ivHdMffdWN3WQ/d0HnfFrFDlgq1VoJ5puZ/UNu3cfvv9");
            sb.Append("3a5huuUyVwYne6XetNwzDXft29hwZ5cjuXNg3IdlxySU8Nfvj0cvhkHmtNbhO/GETpViyPKpSPbKHYbpDmxsO1R7y7odJv5ZIAtmE9poIuen8NP/MD3en50Y6ctpHRxR");
            sb.Append("KnglnlgKWgJO9spWMcyBzQ8eiUSrG0UtnAJyxeUgaxCjCnE2oXSM3398fWFq4tvPVZh7vHgMl1sxKoTDV/842Vrh7Xazqa9Q/oWVO+80s/7uZyOw8PDk+NBbwDOrWeEY");
            sb.Append("Bh9V3Xpvx4Ytez1/5ihhdhg7uhMrugvUFCq4ggrGyaUHEVmDU/M8w6deyoRBeks8oUehxLjFE9pXil3Tf587MTb0dtqu3IvltWNHO/ml/7A6n3xvfmLs57n5uUrl1r2M");
            sb.Append("mNXk5j6mrqHGFoMDKyoujsE+ec1bu25/S9sBz3Kq+Omz/aEKF1qBFjHorrmteXPjpg43uHaSuZlpxi9ytu0J3VpScXG0P6lfTF+7cnDkm1czfubfwvVYPKE/1IptU39d");
            sb.Append("GJ3880u0msZ2QGsar/t/o0Fv79I9/sLVfee/PpxWyr9eH0/otAjDucxlALIZMITfygbnIX2BP7sbncsWNTmCpt3Mz9V8Cl8p+lcFi4ghIpaI2CLiiEjFtj2cnkrxUE8f");
            sb.Append("VscD4onBp9EqGmI1kJ6HmUkyWvNmyeaJiMXiZ9EoehrLBOgzR+mpquax9S14QRYujzLv+zy9fY/+YIliWQyLxYWxAQeoAFzAy2cEiHS2U+9YdDU2483OwKUR0rNzdO94");
            sb.Append("ihMiIksU5y+sojRLnA1AAeHA+3xhmbRoTerSOI92HWSIxd0PdMECrTX5s5FX6gFRoBKoAWqB+qKsa6in/o3naAXW5t/ELogs5P8WJK++4HHBZykq0QXl+VS6xJbJzfxM");
            sb.Append("byb+A19FaWUcddq7AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjEwLTA3OjAwsUuSdgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoy");
            sb.Append("NjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MDk6MzEtMDc6MDDt/ssoAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNv");
            sb.Append("bW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xNVQyMzowNDoxMC0wNzowMO765EIAAAAZdEVYdFNvZnR3YXJl");
            sb.Append("AHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAF3RFWHRTb3VyY2UAR05PTUUgSWNvbiBUaGVtZcH5JmkAAAAgdEVYdFNvdXJjZV9VUkwAaHR0cDovL2FydC5nbm9tZS5vcmcv");
            sb.Append("MuSReQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo3_Reset()
        {
            _EditUndo3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo3 = null;
        #endregion
        #region Image EditUndo4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-4.png
        /// </remarks>
        public static System.Drawing.Image EditUndo4_Cached
        {
            get
            {
                if (_EditUndo4 == null) _EditUndo4 = EditUndo4;
                return _EditUndo4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-4.png
        /// </remarks>
        public static System.Drawing.Image EditUndo4 { get { return _ImageCreateFrom(_EditUndo4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-4.png
        /// </remarks>
        public static System.Drawing.Image EditUndo4_FromFile { get { return _ImageCreateFrom(_EditUndo4_string, "edit-undo-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo4
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1840);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("gklEQVQ4y52UXWibVRjH/+f9yPu2b5M2tbHJYtqmS+eq82LeFNkqtBYVRVacNxMZY0zo1S4VbxRk6qWo6IWDEnqzMREqykDcsjVGZy62OZngNqs2/UrWJQv5fJP3vOd4");
            sb.Append("c1Le5aMXPfDwfpzD7/n/n+fhADusy+dHTyWi4NjFkjptLM6HpjTzn7O7gXYEL86Hpgak1djEyy/tltsK3obOjAH22q7BSieoxYehKt0A/kQiCl6zcMu0cLPGyIUbG2r8");
            sb.Append("zMf18k5guR2U0xXA9SwIodgzYiA4GoQvGPD3eeRSPlvY+9Tj9uvBcfXXeIIVdgRfXBg+5EVqaWJmDFVrFJJ+EADAoQJSAJAGoGh7YPSwoZF9Tz6tanT/AH/4fHBcvR5P");
            sb.Append("sM224Mvn9h436L/fT8yMoWINQyIKZEVzHLFh1YuoVTNYTV0Dhw7D4yEe31BQL6fskQPq1XiCWc1gAgDfzYemHhNlMGkEgAUQHZXSBrJbf7Q2RgEGn3gRN3757fdqMZd8");
            sb.Append("ZQ5zbcHNNc7cr6NQWMdYJAzIfgCAaVZRLqVhlnIgCoGrK4SatR/L1xdvv3AKz3ScitmTq1cW50PT12KbseemA6iInid//Hn7cIH3wB8Y4r196wS1AoweCrh8I8BWi6tH");
            sb.Append("5nj25OqVHPVOJy/dQzgc3v5/+ATI4RMguaJ+LJ99sFUtD3Kb2uCwYDG5h2aOBGjmSKAjWMCvrlUDryYv3QOUUec56a3TDy6kc+Tt9fU8tK5eTq0sZ7YJynRQpu801pDE");
            sb.Append("CKoLn/tfS0TBxSXkcoT6U9Sbz945YP+d9NOLX7u5s1fNiklDlai76/jpdOx2ZvCo2HeCNZlwSJJaLxS767Zd2xRiHnGvNIFVcUgBIM29m1kCMABAd6qqMi1NFCNQzP4l");
            sb.Append("WZSsiIRUBGuASRvFikNF450AIGfP9M663cRfp+rG2ibzlfO18wC6AVQFlAPgzkuItEmiOlzIbjeUyD7jvXCkkv72myX1foZ/9MFn+AGABsASwQBwuQnaaJ4zmQyARCKS");
            sb.Append("sfCp90tvn1mMLZXsjRX2/odfIS7sN6CNUnDiADhtKwBkVYUyeUjzTh6UAx6D9euaPV6uUOmdT3hUWLZF1EVQ8c0aNcabx1ykq4u7TFMhd+8yZtuMgMN+Y9Iy+vuZbzll");
            sb.Append("pf5bxq0vzuGhgEKoY44EjRq3zB9Ba62drpxP7gjmgHIA+B/VvXUxnRhqeAAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xMFQxOTozODoyMC0wNzowMIB9jfEAAAAl");
            sb.Append("dEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA4OjU2OjMwLTA3OjAwFkPu1gAA");
            sb.Append("ADJ0RVh0TGljZW5zZQBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1B1YmxpY19kb21haW4//erPAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTEwVDE5OjM4");
            sb.Append("OjIwLTA3OjAw38z7xQAAABl0RVh0U291cmNlAFRhbmdvIEljb24gTGlicmFyeVTP7YIAAAA6dEVYdFNvdXJjZV9VUkwAaHR0cDovL3RhbmdvLmZyZWVkZXNrdG9wLm9y");
            sb.Append("Zy9UYW5nb19JY29uX0xpYnJhcnm8yK3WAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo4_Reset()
        {
            _EditUndo4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo4 = null;
        #endregion
        #region Image EditUndo5
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-5.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo5_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo5, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo5_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-5.png
        /// </remarks>
        public static System.Drawing.Image EditUndo5_Cached
        {
            get
            {
                if (_EditUndo5 == null) _EditUndo5 = EditUndo5;
                return _EditUndo5;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-5.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo5_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-5.png
        /// </remarks>
        public static System.Drawing.Image EditUndo5 { get { return _ImageCreateFrom(_EditUndo5_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo-5.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo5_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo5_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\edit-undo-5.png
        /// </remarks>
        public static System.Drawing.Image EditUndo5_FromFile { get { return _ImageCreateFrom(_EditUndo5_string, "edit-undo-5.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo5
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo5_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1872);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAFgAAABYA3MXpWAAAA3JJREFUOMutlF9IW1ccx7/m5s8ivUtqF000/2ichhCpkHW0dnZ2ndCStQv4WpiwPfTJwihs0AcfSh/2MAYdDOrDcIVJtcxFbDvGMpsgpFuJ");
            sb.Append("booU01mTJcr15iY33htu7E1MTh+CqHFNHfULX875nXP4nN/h/M6h8Ap94HR+fMZg+ONwQ0NLLJP55VXrt6SoNXnu6NFvvE6n/9urV/UKWe7aL/Sl6vJ4dBdbWv76dXCQ");
            sb.Append("kGKRkHv3yIc2W+R1oe9fdruziYkJQjiu4rt3yQWjcfWMy/VJl8ej2w+H2hn0trUNXmxqGr528+Ybb9lswMZGxQYD3jt+nH5Hr/eR1dUvDwF2Q2vr30mGEV4Grts6ekMq");
            sb.Append("5f+0t7fHNzAAlMu7XSrtiqPhML4bGlpf0Gr7pxYXJ/4T3OXx2NpTqeAXAwP29pMnt0HVrhrP53K4PTSEMUnqf/jkyQ/VYCUAvdvttlucToBlAbUa2Nzchmxubsc72vpS");
            sb.Append("CZf7+oA7d4bhcqEaTiUZhi2q1fGlR4/Otnd2anSCUNlAFAFJqrTPn1f6kgTkckA6DWSzAMPARVFYisXOShbLT2scl9l1eXGOmyMm04NIIHDa4XYbjDYbkEgAglCxLANG");
            sb.Append("I1AoVKArKwDPA6IIVbGIdpVKE0ynPUui+P2eqkgyDEvb7T8Gp6etKknq6PD5gEwGyOeBUgk37t9HWquFbLHA6PVWTsEwQLkMnVIJiectK2bzzBrHPd1TbkmGkZez2fGU");
            sb.Append("LDPRUOhCp8+HeqUSSKVwPRKJPkgkPgs+fiz9PjlpPNTaSjv6+oD5eaBQQKNCgRDLav6RpLGaBf7usWOeSw5HYvHWLULGx6tfnrrH4fjq6/PniTQyQojXS0h3N/ncaiV2");
            sb.Append("s9m8J+OdWmVZRmEy3Z6emnJT+fzbs/H405gobt18KZ7NBopqdZxdWPCdvnIFCIexIYr4k6bn1zhujqqV9RrHbTwThJFYqfRsJZ//WcjlEjvn4xw3V6bpdQ3Pn+s4cQJ1");
            sb.Append("0SgCgpCM53L7/gVr6iOL5SE3Okqk7m7ibWqKAKAUr00FwDc29o/6/ag/dQr6ujoTAO2BgMMzM/8GgsFg2mqFQ6VqBqA5EDAApJqbh2djMVA6HQCoDwwMwP9bKAQcOQKg");
            sb.Append("Rrn9XyUZRjYVCj20Vmtfp+nJAwMDwJttbckEz8uzy8tjLwAFS7ytemeGmwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNjowODo0NC0wNzowMHaWzkcAAAAl");
            sb.Append("dEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjE5OjI5LTA3OjAw0zVaEQAA");
            sb.Append("ADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTExLTE1VDE2");
            sb.Append("OjA4OjQ0LTA3OjAwKSe4cwAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAANdEVYdFNvdXJjZQBOdXZvbGGsTzXxAAAANHRFWHRTb3VyY2VfVVJM");
            sb.Append("AGh0dHA6Ly93d3cuaWNvbi1raW5nLmNvbS9wcm9qZWN0cy9udXZvbGEvdj20UgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo5_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo5_Reset()
        {
            _EditUndo5 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo5_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo5 = null;
        #endregion
        #region Image ChartLineStacked
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku office-chart-line-stacked.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ChartLineStacked_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ChartLineStacked, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ChartLineStacked_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked_Cached
        {
            get
            {
                if (_ChartLineStacked == null) _ChartLineStacked = ChartLineStacked;
                return _ChartLineStacked;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku office-chart-line-stacked.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ChartLineStacked_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartLineStacked_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartLineStacked_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked { get { return _ImageCreateFrom(_ChartLineStacked_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru office-chart-line-stacked.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ChartLineStacked_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ChartLineStacked_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\office-chart-line-stacked.png
        /// </remarks>
        public static System.Drawing.Image ChartLineStacked_FromFile { get { return _ImageCreateFrom(_ChartLineStacked_string, "office-chart-line-stacked.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ChartLineStacked
        /// </summary>
        /// <returns></returns>
        private static string _ChartLineStacked_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1620);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAJhAAACYQBquJjeQAAAAl2cEFnAAAAFgAAABYA3MXpWAAAAnhJREFUOMu1lU1IVFEUx//n3jcfOkZC");
            sb.Append("28CNNmOjgkhRoZhRSKM5JYEugiBtI0S1kXhPjKyZhUEUVIgxBJISRYIzY+Eq+1g6G83INMNdtSqaUod597TxDYMfzRupA5f3zruH3z3vx3k84H+HYRgt/5In1qBepVTQ");
            sb.Append("MAzvdiATZQGKVRw7Efc3VljPNABg5mDWtd8+8ACtut0tqyrVS0qCIM9tKNJ1PZJPl/Gq+n3RioZE1H80EfMfD06UBSh7X7NuiMg2NFZ5ZJdS4hlB6M6UNtw4/5zX12TA");
            sb.Append("zGwL+rqhAd+/ag8EycfNsy8ebVWnZWmotQP+8aXwPDGVALLdVid2HMfLg96Y9+S3uK/Vl6vWtuNYeatTmTRCLHua5598sA3O6Tit3QCLpd3FxYN2DOR0HCtrcxLLM1Cy");
            sb.Append("XTCqq6cGAAAtd1cOOTT2uSS9Gul0fcK6N85kuq5HwuFwh5WPe0+XKiU6iR1noeQsQV5pWnw4dbiPIT2/L7k06nY7eNKlUZ1bA9xOMel0yJt32hzTmzoe952qUopuKSX8");
            sb.Append("xI4hAVkXWBxaAICa678KVrXkoFPRXk3RwdEuz1LfNcbnklQpE+qZkfG50TFrTBADgmU0sDCcsvZ9PcmSdNoclYLeM4vaicuFywDQe5UAYGFtbe24ae7pDIAZANh54afb");
            sb.Append("KVHldvB+U7FuCur3mEW3Xxq5v1INAMLhcIc1xwVdyUqwughwjanUHiXwUbFImCza3vV53tiZiE0dr0UCoMG0SdPJeztW7MI2BVuOl+8XZVTkE7qudxPRWCgUmgOyxs0w");
            sb.Append("jAgzg4isQ2oBvLWbW40JIcZCoVD0bx1E8sy7t/sHyiv+AGwFCCA859kaAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAzOjA1LTA3OjAwcd3pewAAACV0");
            sb.Append("RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwOToyNToyMy0wNzowMIXGO2wAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MjU6MjMtMDc6MDD0m4PQAAAA");
            sb.Append("Z3RFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5z");
            sb.Append("ZXMvTEdQTC8yLjEvW488YwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0wNi0wM1QwOTo1ODoxMS0wNjowMLsFdH4AAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7o");
            sb.Append("AAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ChartLineStacked_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ChartLineStacked_Reset()
        {
            _ChartLineStacked = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ChartLineStacked_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ChartLineStacked = null;
        #endregion
		#region Image KSirtet
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku ksirtet.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu KSirtet_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property KSirtet, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property KSirtet_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet_Cached
		{
			get
			{
				if (_KSirtet == null) _KSirtet = KSirtet;
				return _KSirtet;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku ksirtet.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image KSirtet_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití KSirtet_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property KSirtet_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet { get { return _ImageCreateFrom(_KSirtet_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru ksirtet.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití KSirtet_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property KSirtet_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// D:\Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\ksirtet.png
		/// </remarks>
		public static System.Drawing.Image KSirtet_FromFile { get { return _ImageCreateFrom(_KSirtet_string, "ksirtet.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru KSirtet
		/// </summary>
		/// <returns></returns>
		private static string _KSirtet_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(6004);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAALGOfPtRkwAACj1pQ0NQaWNjAAB42p1TZ1RT6RY99970QkuIgJRLb1IVCCBSQouAVGmiEpIA");
			sb.Append("oYQYEkDsiKjAiKIighUZFHHA0RGQsSKKhUGx9wF5CCjj4Cg2VN4P3hp9s+a9N2/2r732OWed75x9PgBGYLBEmoWqAWRKFfKIAB88Ni4eJ3cDClQggQOAQJgtC4n0jwIA");
			sb.Append("4Pvx8OyIAB/4AgTgzW1AAABu2ASG4Tj8f1AXyuQKACQMAKaLxNlCAKQQADJyFTIFADIKAOykdJkCACUAAFseGxcPgGoBADtlkk8DAHbSJPcCALYoUyoCQKMAQCbKFIkA");
			sb.Append("0A4AWJejFIsAsGAAKMqRiHMBsJsAYJKhzJQAYO8AgJ0pFmQDEBgAYKIQC1MBCPYAwJBHRfAACDMBKIyUr3jSV1whzlMAAPCyZIvlkpRUBW4htMQdXF25eKA4N0OsUNiE");
			sb.Append("CYTpArkI52VlygTSxQCTMwMAgEZ2RIAPzvfjOTu4OjvbONo6fLWo/xr8i4iNi/+XP6/CAQEAhNP1RfuzvKwaAO4YALbxi5a0HaBlDYDW/S+ayR4A1UKA5qtfzcPh+/Hw");
			sb.Append("VIVC5mZnl5ubaysRC22FqV/1+Z8JfwFf9bPl+/Hw39eD+4qTBcoMBR4R4IMLszKylHI8WyYQinGbPx7x3y7883dMixAni+ViqVCMR0vEuRJpCs7LkookCkmWFJdI/5OJ");
			sb.Append("f7PsD5i8awBg1X4G9kJbULvKBuyXLiCw6IAl7AIA5HffgqnREAYAMQaDk3cPADD5m/8daBkAoNmSFBwAgBcRhQuV8pzJGAEAgAg0UAU2aIM+GIMF2IAjuIA7eIEfzIZQ");
			sb.Append("iII4WABCSIVMkEMuLIVVUAQlsBG2QhXshlqoh0Y4Ai1wAs7CBbgC1+AWPIBeGIDnMApvYBxBEDLCRFiINmKAmCLWiCPCRWYhfkgwEoHEIYlICiJFlMhSZDVSgpQjVche");
			sb.Append("pB75HjmOnEUuIT3IPaQPGUZ+Qz6gGMpA2ageaobaoVzUGw1Co9D5aAq6CM1HC9ENaCVagx5Cm9Gz6BX0FtqLPkfHMMDoGAczxGwwLsbDQrF4LBmTY8uxYqwCq8EasTas");
			sb.Append("E7uB9WIj2HsCicAi4AQbgjshkDCXICQsIiwnlBKqCAcIzYQOwg1CH2GU8JnIJOoSrYluRD4xlphCzCUWESuIdcRjxPPEW8QB4hsSicQhmZNcSIGkOFIaaQmplLST1EQ6");
			sb.Append("Q+oh9ZPGyGSyNtma7EEOJQvICnIReTv5EPk0+Tp5gPyOQqcYUBwp/pR4ipRSQKmgHKScolynDFLGqWpUU6obNZQqoi6mllFrqW3Uq9QB6jhNnWZO86BF0dJoq2iVtEba");
			sb.Append("edpD2is6nW5Ed6WH0yX0lfRK+mH6RXof/T1Dg2HF4DESGErGBsZ+xhnGPcYrJpNpxvRixjMVzA3MeuY55mPmOxWWiq0KX0WkskKlWqVZ5brKC1Wqqqmqt+oC1XzVCtWj");
			sb.Append("qldVR9SoamZqPDWB2nK1arXjanfUxtRZ6g7qoeqZ6qXqB9UvqQ9pkDXMNPw0RBqFGvs0zmn0szCWMYvHErJWs2pZ51kDbBLbnM1np7FL2N+xu9mjmhqaMzSjNfM0qzVP");
			sb.Append("avZyMI4Zh8/J4JRxjnBucz5M0ZviPUU8Zf2UxinXp7zVmqrlpSXWKtZq0rql9UEb1/bTTtfepN2i/UiHoGOlE66Tq7NL57zOyFT2VPepwqnFU49Mva+L6lrpRugu0d2n");
			sb.Append("26U7pqevF6An09uud05vRJ+j76Wfpr9F/5T+sAHLYJaBxGCLwWmDZ7gm7o1n4JV4Bz5qqGsYaKg03GvYbThuZG4016jAqMnokTHNmGucbLzFuN141MTAJMRkqUmDyX1T");
			sb.Append("qinXNNV0m2mn6Vszc7MYs7VmLWZD5lrmfPN88wbzhxZMC0+LRRY1FjctSZZcy3TLnZbXrFArJ6tUq2qrq9aotbO1xHqndc804jTXadJpNdPu2DBsvG1ybBps+mw5tsG2");
			sb.Append("BbYtti/sTOzi7TbZddp9tneyz7CvtX/goOEw26HAoc3hN0crR6FjtePN6czp/tNXTG+d/nKG9QzxjF0z7jqxnEKc1jq1O31ydnGWOzc6D7uYuCS67HC5w2Vzw7il3Iuu");
			sb.Append("RFcf1xWuJ1zfuzm7KdyOuP3qbuOe7n7QfWim+UzxzNqZ/R5GHgKPvR69s/BZibP2zOr1NPQUeNZ4PvEy9hJ51XkNelt6p3kf8n7hY+8j9znm85bnxlvGO+OL+Qb4Fvt2");
			sb.Append("+2n4zfWr8nvsb+Sf4t/gPxrgFLAk4EwgMTAocFPgHb4eX8iv54/Odpm9bHZHECMoMqgq6EmwVbA8uC0EDZkdsjnk4RzTOdI5LaEQyg/dHPoozDxsUdiP4aTwsPDq8KcR");
			sb.Append("DhFLIzojWZELIw9GvonyiSqLejDXYq5ybnu0anRCdH302xjfmPKY3li72GWxV+J04iRxrfHk+Oj4uvixeX7zts4bSHBKKEq4Pd98ft78Swt0FmQsOLlQdaFg4dFEYmJM");
			sb.Append("4sHEj4JQQY1gLImftCNpVMgTbhM+F3mJtoiGxR7icvFgskdyefJQikfK5pThVM/UitQRCU9SJXmZFpi2O+1temj6/vSJjJiMpkxKZmLmcamGNF3akaWflZfVI7OWFcl6");
			sb.Append("F7kt2rpoVB4kr8tGsudntyrYCpmiS2mhXKPsy5mVU53zLjc692ieep40r2ux1eL1iwfz/fO/XUJYIlzSvtRw6aqlfcu8l+1djixPWt6+wnhF4YqBlQErD6yirUpf9VOB");
			sb.Append("fUF5wevVMavbCvUKVxb2rwlY01CkUiQvurPWfe3udYR1knXd66ev377+c7Go+HKJfUlFycdSYenlbxy+qfxmYkPyhu4y57JdG0kbpRtvb/LcdKBcvTy/vH9zyObmLfiW");
			sb.Append("4i2vty7ceqliRsXubbRtym29lcGVrdtNtm/c/rEqtepWtU910w7dHet3vN0p2nl9l9euxt16u0t2f9gj2XN3b8De5hqzmop9pH05+57WRtd2fsv9tr5Op66k7tN+6f7e");
			sb.Append("AxEHOupd6usP6h4sa0AblA3DhxIOXfvO97vWRpvGvU2cppLDcFh5+Nn3id/fPhJ0pP0o92jjD6Y/7DjGOlbcjDQvbh5tSW3pbY1r7Tk++3h7m3vbsR9tf9x/wvBE9UnN");
			sb.Append("k2WnaKcKT02czj89dkZ2ZuRsytn+9oXtD87FnrvZEd7RfT7o/MUL/hfOdXp3nr7ocfHEJbdLxy9zL7dccb7S3OXUdewnp5+OdTt3N191udp6zfVaW8/MnlPXPa+fveF7");
			sb.Append("48JN/s0rt+bc6rk99/bdOwl3eu+K7g7dy7j38n7O/fEHKx8SHxY/UntU8Vj3cc3Plj839Tr3nuzz7et6EvnkQb+w//k/sv/xcaDwKfNpxaDBYP2Q49CJYf/ha8/mPRt4");
			sb.Append("Lns+PlL0i/ovO15YvPjhV69fu0ZjRwdeyl9O/Fb6SvvV/tczXrePhY09fpP5Zvxt8Tvtdwfec993foj5MDie+5H8sfKT5ae2z0GfH05kTkz8EwOY8/wlYzOiAAAAIGNI");
			sb.Append("Uk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAAGYktHRAAAAAAAAPlDu38AAAAJcEhZcwAACxMAAAsTAQCanBgAAAAJdnBBZwAAABYAAAAWANzF");
			sb.Append("6VgAAAVDSURBVDjLnZV7bFR1Fsc/v/ucO4/OtDMd+q5iC3TxgVRa0aCurgkaMcFdV3clgZj4imjUKNFGDBHBIFFj4iNmfa7GV6xRxN1NxF0LBqvYLqWlxbYgQ5nSmTpt");
			sb.Append("ZzqPO9O59/pHra8oIZ4/T3755Py+55zvERs90BgETYcQ4DJUrDIV/+oV5HUDkc1TPRqnReoidCnIGQg6EAd87+3e9tmujt3LNm/8aEaAWYCcDCO9IPE74uM1z9S2Hh50");
			sb.Append("blx7zoa27bfujH6w6/VfvvlN8A13fdLya/kD9z276t6nrz52xukBvh5JIqQid65vvcEZGXcOPdQWOCk43Xzb+L/ffeuLtx/98oGf5k881r7l/q1/3eHxqERTBVK2IKtI");
			sb.Append("fNKXZPBwCrmy4o+/Ct4+RNnMqrvtpgtbQ9lCinu2bd76bXvnPwGYOPLhbXf8qS1vWcRMm5yQsA2d/miBPT1ZZLcJktk5xxJzzfvvqFh866a2vkBtDbnEOKqYod4zw3Bf");
			sb.Append("hK3qzdSsuIhCeoJc0cZyHFRDZShh0dmdRJem0pmDx5sb/756cK55CsBA3n/N+odvb9d9bnLHh1Ediwp7nB17c7zY+Aj15zUxnZmk4MigatgyFGSZuloFu9RL50eRlWet");
			sb.Append("Wz1oFn78vXhySePDq265eWMum8aajCHZM/itKV443kBH84PUV2rYtollC2zZRySVJeCTcPtc2CooLohmoXOPc8miGqnjh3GbX1W+0ZyMo3sMVEVCt02MQpqgZkJAIy87");
			sb.Append("mEIjJXkYSHxNc+0a4lNvEy3OMC3BSBYSlsW6lfd9Ggywea5ieY0/v8mybAKVlbh1CZUiilxkhdFH6f/bea/0z8TDHhKxfdx15TauWlpDnXc3+yOTRMQSTFHgUvMaztdy");
			sb.Append("XLni2ouS2rHmvgNTb8p/C2c3FTNJtNA8SsLzUFJRVHLYkovFJRO0DP2Lj/U8t6x9jobyEGMZG7/fzyL/XlL5fpYrL9Pgs/E2leEIaG1YujBb0fsX8VI1Z54xX+lN6iFC");
			sb.Append("F1zBH5oWoO/fhZ0eQYTr0F0uJs0xti2bpHp5A1WGwsyMCxkNxUqSzbvJ4cWy07hcCTpG+3m1M4Z8tk1cKdqPV4dza6fHoiXfolOxZBkezcQxx8l7XfiCTTRFwnw+/QVS");
			sb.Append("xSRud4IMSdJSnhQxMnI3jtHNvmMpXvl0fFbjizUoMyhkUs4TtXXWZWkzXT+RdyhfehmuujCSVyFTqlHeWMrZo3V0mENooQyqN0JWGUHoMUJGloEjC3jt8yl0v0Ux5RyS");
			sb.Append("L9Yg6AZZAWms+LL3gvqaIs7SRDxBRagKZfFitLog04UM7fZBlECY+prT8ChBSoRFpVDYM7CQN7oO4/NkEaP8LzdEy8/AbkA+kviQ1gXZbNG8PDEyTGU6z5ShsjMWwbew");
			sb.Append("kSVnLsKjlODBwEeY13ssdg73UGoUyUd4Xje4NhX/XoqfghVVxh45vtc6t7FH0rTrpw4PMJjZT8NVD7G8sgVJePBTgoXCY9072DdxiHIFpvvZ4NJpK0qQGj+JbZY7hfdN");
			sb.Append("M7/M462lt3CUx2P34uIsqliJ7cxjS+8THCsepVaC1CGu8/jZPrvLs9Z2UqMvCXq+KiaOhlJ+I9kz/CUb+puZsIbZMryGtByn0oTRXpoNF+8gQEggVBD6KVyQ9PyaxFM9");
			sb.Append("E9UNLk5EE928Fl2PKBmjbILRwYMEDD/dCBDyLFB4QQRO8TQNaM2Zzv9Q5c/JXZp7DOWo+KorRrWqk4RZqOQCuRS+uW6a4oOxWds81djrWOdJnb03Deadf8zpKWSQNJBK");
			sb.Append("oeuKNHACKPAdRwYyHKwlKoEAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTEx");
			sb.Append("VDA4OjQzOjIxLTA3OjAwKmRJxAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo0MzoyMS0wNzowMFs58XgAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0");
			sb.Append("aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMTo0Mi0wNzowMBWMbBQAAAAWdEVYdFNv");
			sb.Append("dXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property KSirtet_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void KSirtet_Reset()
		{
			_KSirtet = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití KSirtet_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _KSirtet = null;
		#endregion
		#region Image ListAdd
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku list-add-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ListAdd_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ListAdd, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ListAdd_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-add-2.png
        /// </remarks>
        public static System.Drawing.Image ListAdd_Cached
        {
            get
            {
                if (_ListAdd == null) _ListAdd = ListAdd;
                return _ListAdd;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku list-add-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ListAdd_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ListAdd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ListAdd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-add-2.png
        /// </remarks>
        public static System.Drawing.Image ListAdd { get { return _ImageCreateFrom(_ListAdd_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru list-add-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ListAdd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ListAdd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-add-2.png
        /// </remarks>
        public static System.Drawing.Image ListAdd_FromFile { get { return _ImageCreateFrom(_ListAdd_string, "list-add-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ListAdd
        /// </summary>
        /// <returns></returns>
        private static string _ListAdd_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1024);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAB");
            sb.Append("HElEQVQ4y+2Uv0rDUBSHv8QKFhc7CE4OTu7JWApFH6OLQ+kgiE8gdRAXX6C49hW6toODS+/i3sHZxUFFMfccB9PQ/LG5gQoF/cElucnJd0/O+d0L//pteS5BYXc4BYJ4");
            sb.Append("aqa3nbDsG98xgeCy16bfa7OwwErAlbUeYK0QW8s+yDQqDdUkJrtGrqE5MBDcnB3zKZpYxvd9Xt8jVOH69IhIFFVQ/bbVxWCcS6QIzMuH5fHpDVUQUUTBimIFIgFrlUgU");
            sb.Append("ETjYq7uVAjD9wSSXwXmnhZk9c3f/UMQxpeAi84fdoXrpmNKN5eyKne1NpIIt3O0WN2tV4I35zf7uFs3DRvb9jyWpsVw2vpqTq1FyCKX/o1gup5u3MOYwcS/Kn9cX8BRe");
            sb.Append("NHBBR1cAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTBUMTk6Mzg6MjAtMDc6MDCAfY3xAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE3LTA3");
            sb.Append("OjAwkaRNqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo1NjozMi0wNzowMIHc//8AAAAydEVYdExpY2Vuc2UAaHR0cDovL2VuLndpa2lwZWRpYS5vcmcv");
            sb.Append("d2lraS9QdWJsaWNfZG9tYWluP/3qzwAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xMFQxOTozODoyMC0wNzowMN/M+8UAAAAZdEVYdFNvdXJjZQBUYW5nbyBJY29u");
            sb.Append("IExpYnJhcnlUz+2CAAAAOnRFWHRTb3VyY2VfVVJMAGh0dHA6Ly90YW5nby5mcmVlZGVza3RvcC5vcmcvVGFuZ29fSWNvbl9MaWJyYXJ5vMit1gAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ListAdd_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ListAdd_Reset()
        {
            _ListAdd = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ListAdd_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ListAdd = null;
        #endregion
        #region Image ListRemove
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku list-remove-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ListRemove_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ListRemove, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ListRemove_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-remove-3.png
        /// </remarks>
        public static System.Drawing.Image ListRemove_Cached
        {
            get
            {
                if (_ListRemove == null) _ListRemove = ListRemove;
                return _ListRemove;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku list-remove-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ListRemove_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ListRemove_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ListRemove_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-remove-3.png
        /// </remarks>
        public static System.Drawing.Image ListRemove { get { return _ImageCreateFrom(_ListRemove_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru list-remove-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ListRemove_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ListRemove_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\list-remove-3.png
        /// </remarks>
        public static System.Drawing.Image ListRemove_FromFile { get { return _ImageCreateFrom(_ListRemove_string, "list-remove-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ListRemove
        /// </summary>
        /// <returns></returns>
        private static string _ListRemove_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(828);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAWAAAAFgDcxelYAAAA");
            sb.Append("iklEQVQ4y+2QsQ3CQAxF30k02YCaFZIRMgYtLSMgBmCBiJY5YIFkCGpahIQS+6egQWCKq7knufn6erYMhULhJ+kzaDanHqgzPUN/XDfvwSIo1Ydty+giAaMpNEmvScCu");
            sb.Append("O38dEom5P43r7YEE7sIF5sIcJgczMblwh9WyChdH4mHfXbJfkdkvFP6bGVdiMdtsf72WAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTEwVDE5OjM4OjIwLTA3OjAw");
            sb.Append("gH2N8QAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNy0wNzowMJGkTagAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDg6NTY6MzEtMDc6");
            sb.Append("MDCwNOViAAAAMnRFWHRMaWNlbnNlAGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUHVibGljX2RvbWFpbj/96s8AAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEt");
            sb.Append("MTBUMTk6Mzg6MjAtMDc6MDDfzPvFAAAAGXRFWHRTb3VyY2UAVGFuZ28gSWNvbiBMaWJyYXJ5VM/tggAAADp0RVh0U291cmNlX1VSTABodHRwOi8vdGFuZ28uZnJlZWRl");
            sb.Append("c2t0b3Aub3JnL1RhbmdvX0ljb25fTGlicmFyebzIrdYAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ListRemove_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ListRemove_Reset()
        {
            _ListRemove = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ListRemove_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ListRemove = null;
        #endregion
        #region Image LockBlue3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku lock-b3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LockBlue3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LockBlue3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LockBlue3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-b3.png
        /// </remarks>
        public static System.Drawing.Image LockBlue3_Cached
        {
            get
            {
                if (_LockBlue3 == null) _LockBlue3 = LockBlue3;
                return _LockBlue3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku lock-b3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LockBlue3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockBlue3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LockBlue3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-b3.png
        /// </remarks>
        public static System.Drawing.Image LockBlue3 { get { return _ImageCreateFrom(_LockBlue3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru lock-b3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockBlue3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LockBlue3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-b3.png
        /// </remarks>
        public static System.Drawing.Image LockBlue3_FromFile { get { return _ImageCreateFrom(_LockBlue3_string, "lock-b3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LockBlue3
        /// </summary>
        /// <returns></returns>
        private static string _LockBlue3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2384);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAFgAAABYA3MXpWAAABPRJREFUOMuNlUuIZVcVhr+zz+u+X1XV1XWruquKSnWwNelKWkXpDFoQFemgEEIkEBRiRgEd6MSBJKIE4hPBQQYBcSCCaBA1DTrQiYKKmHSn");
            sb.Append("o3l1ma5q69n3dp1z77nnsc9e20EZ2yRldMGarM36+Fl7PRz+q90F/fuhXkUFAUopsBYpNJIVMJ7A8CLwxyOz3SOjt30LTtzDuac+z+Z3f+pZqEpR1iXNK3aUeOzs20++");
            sb.Append("/oS89OME3HOQ/vZtCOdtkdXvsPiZT3Dtez+q0W3PtzuNd1frlVXP9aZFrKMzfSMbTa4mN+MXZRhtPh09nny2+zU4+PI7gJeehJ09h+XF+c5s78P9ud6F/lz3bK/XmgnC");
            sb.Append("INTaEkdZsb8XD/a3B88NtvYujncHv2J3f4N6TUi+elQpPg3acVheXukvH39k7czyo/d8YPWDZ9eWugv9XtDt1FW7XVftXsvvzvTa1Wb7lHX8M7o07dzIJlE0gPdY+Mtb");
            sb.Append("wZdg5VMLc8vHH3n/+257+Py5UydWFqecUhtskTBdLWiHmizLGKWCX6k5fr3dLsW9vUhzvyj0y2QvHsBrbwH3n6h1Th6/96615UfPnzt1YmG2xUGc4+gx75pzaFagWYWT");
            sb.Append("0y5xUrCxmyEoJGhWi0wWiiTZLcfVvyGTArZRAEz9DKfdWpjr9y7ccXp+cW6mySQ1xKMJK8cUo8zymys5v34+YzAS7l4JcR1NHCeItYRTs3NBa+qCqjeXYewA/wIXf/Dq");
            sb.Append("3cbpRrf73kqr62aFZRBllFrTqCr+vltwfWC4Pih5ZaugXVW0aw6jiSZJEsRzlN+orXm12p3wsQDAA6DdCCu16mrpNaYvbSniNGWmknF63mWh58FqlcUZjQhMNxUL0z4f");
            sb.Append("urPO9X3NC+tjtBGsrzrKC1agHgL5IdjzfVe50wYvvLKZ88q1nPvPOiwdC7iykXMjNohYjFhuJobh2HCqH7JyXPG7S2MslhA8lOqgXBd5Q7EFa8QREbK85B/DnEHsMxwL");
            sb.Append("v/jzmM1d4Y23UVpy8pjLwx/tEShDWaSgXIwYrIiDWG6VIitKKcqBZHnh14xnxVCKS2ksG/sFl69luAilNmRZQdULMaXFWosVg4OD5LqUooygNLfAUZQXSfpaMYqHYW2q");
            sb.Append("5jsGrGCxxJOSrRsp2BLMoWe5wgJYwbGCEpAkiyUr1mGS/4fib+r04Nt/TQbD55qtqX4jrCjHWkLPod/zWJz1QRTWujjGoz9dIfQdwOK6HnairYnHL0iaXIZXi1tgQA+j");
            sb.Append("jVFj8Kxfa641j82fyE1I4CseOt/lI3c3wdrDv7CW6aZLo+oSZwolLvrmwb6Joou2GK2Db988eVmhtVoaINLyPXW7BNVqYhzSrGSSlkxSzSTVpKlmEGv+9GrG75+PGFzd");
            sb.Append("G5U7e8+Y6OD72Ne34RnepBjuwG7vbMRin5ZSnDLN7tu63lsgCChKTak1YgwOFkegGOek28NdvbP7czkYPoVEV6Ftj16b7cchuqnozS5WWq2PB63WvareOEMQdAR8MYLk");
            sb.Append("ujSTNDLR6IrE8bMyGv0SG12FioFvvMOi73wFDh4D70tNt9Fc8qq1M8r3V6yjOoh1pNCRZPm6SSeXbTFeh59E8ADw5P+4IACVx3DqTezgi8DnQqiHhxNlOezTSQ4/LBz3");
            sb.Append("C9aaCPj6/3Ga/m0PglqEIER5PjgOiMXqEqs12BzYA35wZPY/AdNfmD4xT7AGAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQ0LTA3OjAwdpbORwAA");
            sb.Append("ACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNy0wNzowMJGkTagAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTk6MzAtMDc6MDCKBx9c");
            sb.Append("AAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVU");
            sb.Append("MTY6MDg6NDQtMDc6MDApJ7hzAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9V");
            sb.Append("UkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3RzL251dm9sYS92PbRSAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LockBlue3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LockBlue3_Reset()
        {
            _LockBlue3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LockBlue3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LockBlue3 = null;
        #endregion
        #region Image LockRed3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku lock-r3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu LockRed3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property LockRed3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property LockRed3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-r3.png
        /// </remarks>
        public static System.Drawing.Image LockRed3_Cached
        {
            get
            {
                if (_LockRed3 == null) _LockRed3 = LockRed3;
                return _LockRed3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku lock-r3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image LockRed3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockRed3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LockRed3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-r3.png
        /// </remarks>
        public static System.Drawing.Image LockRed3 { get { return _ImageCreateFrom(_LockRed3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru lock-r3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití LockRed3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property LockRed3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\lock-r3.png
        /// </remarks>
        public static System.Drawing.Image LockRed3_FromFile { get { return _ImageCreateFrom(_LockRed3_string, "lock-r3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru LockRed3
        /// </summary>
        /// <returns></returns>
        private static string _LockRed3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1792);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAZdEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAAEpElEQVRIS8VUbUyTZxS9xdIW2kopQoUB7UCgikCpKDFzGj9+GDXGqDNTyMaMyeamG46hm5kzExVh");
            sb.Append("IxbdUPlQNpCGyQAbdcw4Fp3MGNE4mRpFsfS7vYk/Fs1MRM+eFxND5sfM9mNvcvLmffLm3POce+4l+r+e3Xkkb8ogtT2VdBIOmEljm0Th/1pPUypFOsZS2gk1LTqlVZT+");
            sb.Append("Gh1R0aNTVp7Uydd3xdCSNiOZG7JI/cIFbNkk6zRQYreCis7Hx7Vdz7Hc8s6YeSc0Z+59njHzvi9v0t0bGSZXb4L2cJeB3m4xk0ncIOy5BaozSeYw0LgetXLb9Zzcm1zw");
            sb.Append("1gMu3QIuLQOv/QS8qhj8+irw/NfA1kkP+02xg90G2U67mTKrn0feEU+Jp5WKbc6p0wO8bhO4fA94Yzn4488Q2vElQtsrwO+sAS9YCp69AGzJw6Ax5nZ3AlU3ZVFKoYlk");
            sb.Append("TyhvFp7+rKKiYaUSaVX9I9JNZfC22OE5aIf724NwN9sRfHctOH8aOHcKODkFNxMjPEdTaU1NHmmfIHbEU3pv3Jg2XrFyiCtrwWU2cf0N8H/TDN+eOnCRsGD5G/DadsFV");
            sb.Append("34jQKzPA49LAiSawXvPgbBJ1HbRQtiV6hOqvMkl+IpIWDRhTnFwkfNxSDS7+FLy6GL52B4LrN4qrzwO/OmtY7WBbOwLzF4INBnC0HqyKQF9cWKBjPBV+kUvKx6objaT+");
            sb.Append("RSEr5bHJdzhrLnixULe6BKGaffCcOw9Peyc8X++Dd3cNXPZWOM+eg7vKhmC2BX6ZTIBwOYruHTHT5trJNPoxcUsS6c5owis4Nvk+UzJYKbByDbzHjsPX0IhgRRUC5ZUI");
            sb.Append("bC2Hb8t2UWQvXEePwbV4KQYUhBsCgnjoh3TaWT+Foh8T25NJ16OVV3JMoiAeCyYleOEy+Jvs4i0SYBVNEgngDDM4IQmBqdPh3t+EgRUF6IsgXFURLuloSCi21Y0kbkwj");
            sb.Append("zSndqA1BfczdR8Thw1n1H2gC5+SLbxVYLiCTwxdGcKeZ4a5rwM3lK3AxUqgV6I2le46J9PmevBFWVGdT+I96WtIfE+VmZYIgUgjipfDtbwanTAALVX4Bl5owoCE4k4xw");
            sb.Append("1dajXxBfEOeXxVlPEoXarPRmpWVE8yRPDiXR+LN6hYNH6x8waQTxYpHfVoSmzUZQMRo+AZdCC6dSg8EpU+ESMbwmiH8TNlzU08PjZvqpMZ9yC/4+JA2ZpJZm/4o+wsWq");
            sb.Append("aPCchfAd6oRPZNa/tRI+Ae/WHfCUlcMtcu36/jBuzZuPK1rCaRMFv7NSidgZUU/dGa3pZOqOo53XolW3OVU0qmAVgiUb4F23Hq7iUjg/KIGz+KPht3dZIZwJcRCD8Uen");
            sb.Append("hepEGtLfz3jKSEuVpC0lLZQT8WTrG6Nwe6LUCKrU8I5SwklyDFAY+gVuiNxeFX6fMVLgcDbVNuSTVXg76rkbrspKYS0T6WXHOHrv5EvU1TuG/H06+vN3kdNLehq6YKB7");
            sb.Append("p40U7BKetlrpQ0npP5KOrLh3MmlbciirYwIVHsmgzVL4j4mcSpE6JLovNWpX3jM8fZHtL82+NKbSREnhl3IqRSpO+Qw/X4T0v/zzF8s0csXmq387AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property LockRed3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void LockRed3_Reset()
        {
            _LockRed3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití LockRed3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _LockRed3 = null;
        #endregion
        #region Image MailMarkImportant1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MailMarkImportant1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MailMarkImportant1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MailMarkImportant1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1_Cached
        {
            get
            {
                if (_MailMarkImportant1 == null) _MailMarkImportant1 = MailMarkImportant1;
                return _MailMarkImportant1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MailMarkImportant1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1 { get { return _ImageCreateFrom(_MailMarkImportant1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mail-mark-important.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant1_FromFile { get { return _ImageCreateFrom(_MailMarkImportant1_string, "mail-mark-important.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MailMarkImportant1
        /// </summary>
        /// <returns></returns>
        private static string _MailMarkImportant1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1584);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAWAAAAFgDcxelYAAAC");
            sb.Append("20lEQVQ4y+2UPW8UVxSGn3vnzuysvcTeXcfBMsl610BMEEmUIASioXCkCPlnEIr8ABoKKjeW0iBRoUhIKEqHd21REDkdVUSiKMJJFJBooECsWWIU73zcjxQzu541ToOg");
            sb.Append("y9UcnXvujN5z5r3nvPD/ettLvAmQe+D2nqmVb1aWPMHNVKeTr4186TLHrlwBa8Fa/lheRknpblz86uvJyngF57LERZ/tXb7ffTc4A9i8dBmShKTdJlhaAkDqVNeVp7i/");
            sb.Append("eR8hBM45rLUYY7A2M2MMxthCrNFa45wjDMtZmjge8RKgVCrx7tQUGz9uIKUEXAHQYK3dExs8T1Iuj3HnhzvZD+SAFIGFENTrU8y3Wqytt1HKR0qZV2hHAK01KOUThmN0");
            sb.Append("1laZm2tklSbJqxU75xBC8N7Bg8zPH6GzvorvByjlj4AaYwiCEmFYprO+ylyzyfT0dFZpDjzwcnCx2qRIKTk0O0uj0aS9dosgKBEEwbDyMCwThmXaa7eYnX2fmZmZnLpd");
            sb.Append("ClwR2DmH1hpjNJ7yqNUmqbxzgM76KmFYplqtU63Wh5WOVyrUalWU56FNOkLBIIHKGwdtNDjo93fo9bZYPPcFj5885rvvb+L7PgBpmnLm9FlazRa//PoTvvIISqUhBbLR");
            sb.Append("GCZQecNitCZKYrb/fsEnJz4niiLGx8qc//L8K/PQ623x2aen2Pz9N8YPVAD46/btkW9yKiCKI6J+n4Wjx9np7xDFOyDE0JzI5tYBFtjqdTn+0cckcUz10QNOJDEbK8uc");
            sb.Append("BHEShNrlOKU1d5hn3ackaZxNWp7V4ciebPoGU7f98gVHDx/jZyHoAYsF3VBKqefa6NoHh5qkacLERHU4snulxe0TxUkEkGlFkuC6Xf68fh21/fKfi9euXf3WWDPxuhq0");
            sb.Append("mHdD0ungLSwAmWzK/BIV4BVM5ibYldcizRYwgLkH2x9euIDrdrHdLg/v3t1Xj0UB8L+Ai+BuPz1+a+tfDKeVj47GNx0AAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEt");
            sb.Append("MTVUMjM6MDQ6MTEtMDc6MDAXPJnCAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjA5OjMzLTA3OjAwCzxivQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0w");
            sb.Append("MS0xMVQwOTowOTozMy0wNzowMHph2gEAAAA0dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvR1BMLzIuMC9sagaoAAAAJXRFWHRt");
            sb.Append("b2RpZnktZGF0ZQAyMDA5LTExLTE1VDIzOjA0OjExLTA3OjAwSI3v9gAAABd0RVh0U291cmNlAEdOT01FIEljb24gVGhlbWXB+SZpAAAAIHRFWHRTb3VyY2VfVVJMAGh0");
            sb.Append("dHA6Ly9hcnQuZ25vbWUub3JnLzLkkXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MailMarkImportant1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MailMarkImportant1_Reset()
        {
            _MailMarkImportant1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MailMarkImportant1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MailMarkImportant1 = null;
        #endregion
        #region Image MailMarkImportant2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MailMarkImportant2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MailMarkImportant2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MailMarkImportant2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2_Cached
        {
            get
            {
                if (_MailMarkImportant2 == null) _MailMarkImportant2 = MailMarkImportant2;
                return _MailMarkImportant2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku mail-mark-important-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MailMarkImportant2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2 { get { return _ImageCreateFrom(_MailMarkImportant2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru mail-mark-important-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MailMarkImportant2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MailMarkImportant2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\mail-mark-important-2.png
        /// </remarks>
        public static System.Drawing.Image MailMarkImportant2_FromFile { get { return _ImageCreateFrom(_MailMarkImportant2_string, "mail-mark-important-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MailMarkImportant2
        /// </summary>
        /// <returns></returns>
        private static string _MailMarkImportant2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1880);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAN2AAADdgF91YLMAAAACXZwQWcAAAAWAAAAFgDcxelYAAAD");
            sb.Append("XUlEQVQ4y7WVT2hcRRzHPzPvbd5m3/7NJpvYSLU1GqMWtJTQEDAtlB6jgn8OXsRLDx6qFy0qCh71oIgn/xwsHlKskdy8WEM1oiDUppDStJBSaZLdZJMm2X/vzcwbD8lu");
            sb.Append("tC2SVvqF72Vm+Mx3fvNPWGvZoUR1ZmZg7p23j1enLxzVG+teVKl4wtqLKPWNgG+HtSm3Bu8UPJXveF4gPrvvpRe604ODtOVzREGAKpWpXjhPaexU2VQqzxxUZqoFFkL8");
            sb.Append("J/SsI4cTe/acefCtN9scP4FVChMqUBqrFRhD1GhQ+urLMLh69cUDKpoQQDvwSHMFN0OHhch8mElPPHTiRMbNpLFKUduo0Pn6GwAsfvA+7TEXoTRR0GDx5MnyxzfW+1zg");
            sb.Append("QLURnPVc57Zpl774nLXx7xDWopeXsVqxsVwmZwwAlYUFPN/HKoVViuy+J/OHp35+zwXkH1du0JOWPFBI3QJePTWG39eHKS9htd5MXCxhmuBiiVw6BVvgtmyaAckRF6Ar");
            sb.Append("k6SmNL/OFBns7/xXPfSVWejdhTYatAalqC8ttcC18jKRCrYSh8hCgTg27QLEHIg5Ln53np+mi+zfmyGdaAPAzWQJLs4g43FkLIaQDqZaRWsNQLi6QtSogQpBa9T8PHFB");
            sb.Append("ygVwnWZGwRN7e7hcXKVdVui/P0OsI0fw+28IQGARQNLC6d4eDHBQgpHbuy6AuuUvuZ142327ciSTac6cn8cbfRYHu2VwgIaA0blrPDd3jUDQam/6kuXHLbC4xbmUh7GS");
            sb.Append("Xx59GqfQjSNo2QeiKCKKIvwmsNmfz/OpYVIAI+X1xuQ/T4I2lnOXrrO/L0fMkcx+PUbnu8eRKsTxk9hUmtDzEK5Dm7A4jQC7tkYUhsTHf6Bw5PCh1uY1FaqIuetLDD1W");
            sb.Append("aNVt4NWXKe3uRb72Co6UuPseJ/VwPyLuYRYWUdN/YiKL/9EnxIaGWrUeqTWCSYBAGRbLG+zuSt72stiVFYKJccLvT2MuzyKyWURHntrRUfLHjuH5CQASce+QAEaCIJis");
            sb.Append("B5paoOhIxXf0KN2slY0GCS9Gu+fied5mKeqhQUpJV9a/KyhAV9anHmjq4ebFcQGbbPeQUtw1tKlkwiGKLIAVQBbcp1rT/F9pAH2OO/hBdixr7c5/kDuVvCfUewn+G7cJ");
            sb.Append("eJvLgrJfAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE3OjAzOjA1LTA3OjAwcd3pewAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNy0w");
            sb.Append("NzowMJGkTagAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MjU6NDgtMDc6MDAw896tAAAAZ3RFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMu");
            sb.Append("b3JnL2xpY2Vuc2VzL2J5LXNhLzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvW488YwAAACV0RVh0bW9kaWZ5LWRhdGUA");
            sb.Append("MjAwOS0wMy0xOVQxMDo1Mjo0NC0wNjowMOH60j8AAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRTb3VyY2UAT3h5Z2VuIEljb25z7Biu");
            sb.Append("6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MailMarkImportant2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MailMarkImportant2_Reset()
        {
            _MailMarkImportant2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MailMarkImportant2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MailMarkImportant2 = null;
        #endregion
        #region Image MemoryRom
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku memory-rom.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu MemoryRom_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property MemoryRom, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property MemoryRom_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom_Cached
        {
            get
            {
                if (_MemoryRom == null) _MemoryRom = MemoryRom;
                return _MemoryRom;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku memory-rom.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image MemoryRom_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MemoryRom_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MemoryRom_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom { get { return _ImageCreateFrom(_MemoryRom_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru memory-rom.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití MemoryRom_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property MemoryRom_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\memory-rom.png
        /// </remarks>
        public static System.Drawing.Image MemoryRom_FromFile { get { return _ImageCreateFrom(_MemoryRom_string, "memory-rom.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru MemoryRom
        /// </summary>
        /// <returns></returns>
        private static string _MemoryRom_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(2172);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAhWAAAIVgHhrxhDAAAACXZwQWcAAAAWAAAAFgDcxelYAAAE");
            sb.Append("n0lEQVQ4y42Vy28bRRzHv7Mz67W9ie1ssONHSt2EpnnRUhXaVByQKpGCBBInTvwV3Pg/OILUcuOA4NADElwqNVWB0kfStGmSBruJE3vj1673vbM7HGiqAm3S7+03Gn30");
            sb.Append("1cx85wscLbK4uAhCyGtsPULZbBYAGIAiY2wagPZspleuXgGl9Gg3Lw7JZBKe51EAo8PDmTPZXO5yIpF4y/Xc33kY3JcZ82zLWTdMYxdA9LpgCkBTVXV+RNMW38gXPiyV");
            sb.Append("yzOZTCbV7XV7MQ/bmcyQ+2Tjyc8rKw++FULUbt26Hi4sfPBSMDuAJlPpU7lc7vOxYnFxrFSaK5XKmWPHxlEoFNDtdbWBaWjJZAKWZWd2d/c4Y/TepUsf3QNQA8D/Cz44");
            sb.Append("rFSxVPzs5NSpL09OT88USyWlUiljfm4W1TePI5VMgckywiCCaVnq6OjozOzc9PtDQ0MF0zBqlDEdAojj+P+Os9ns6JvHj4+Mj4/DDwLwKILjuHDTLhRFQaVcQSaTQch5");
            sb.Append("wjTNoixLRdfzh1Lp9F5/b49BoAGgQwiJhRDPHWfz+fylarV6IZ/PMypJCIIAvX4fcRwjkZAhywxaLodKuQxKKSzLgb7fViBQPXGien5U0ybCMPQdx20DCCkAqVDIT71z");
            sb.Append("9vQXCwsXTqpDKgmDEJRSRHEM0zRhDgaI4wiUUmjaKDRtBKY5wPZOg0mMaWNjY9VypXQ6juOCbdkrvu/vMwBkRBtJn5qe0mZmp8jq6iM0m3vI5kaQTiYRcg7bsjAYDNBq");
            sb.Append("tuB5Pjjn2Nx8As45BEA6PYOqKSVLQCaZzHIACAMgJEkKiCQFQRhgc2MDjx9v4L3zF6AoCiRJAmMMruvCME08WltD3zDQ0nXEQoCAwPM8BJ4L13VjEQsBABIAwTn3fc9z");
            sb.Append("A99HMpnEuXNncfHiuxgeTsLzPAghkEqloCgKOp0uDMMAYxQyY5AkCQAghIAQQgAifg42DdPafrrT3NqqhYQA48cqkGUZDx884Hdu/+G1dT0OgxCSRJFOp5BOpSDLMgAg");
            sb.Append("iiMEgQ/bsiLHcbqccxuAYADQaumte3fv/7jfbhcTicSZfCGfNU2Dra9vuH9t1ZyJyRPacEaVOp0eojgGIRLiKEbIORzL8ju6Xh8YRs33vZ88z68DiA+eW9jt9ur1Wn2N");
            sb.Append("h2E4Pz9XzY3khldXH9KJyUnlk08/llOpJKnX6rBsBzzksB0b7X190NxtXNdbra/7/d5V3/eXoigyXgwIKKV2FEVLvu976+ubE47jXnYdT3779DEpm82Q5eWV6O6dPzuS");
            sb.Append("JCfSQ2q20+40G42da+39/e88x7lNCPHEP/f2r0jjYNG2bWMwGPQaOw3R0vX+7NyMWioV00s3bg6Wbtz8vtvp/GYaht3W9R/0ZvObwPeXAYSv+oRelF2v1X+pA6uqmj7L");
            sb.Append("Q/5VEIZ5SZICAnK71Wz+SggZE0I8FULoryqAl4FBCPEURdkKecTXHq0tq6o6ZfQNQQgJZVneDcNwO5fLHdoqr6wCzjmiKHIdx202dnexs93Y6fV61zjne3EcC8/zcJgO");
            sb.Append("LTJCCIQQMqW0QilVoiiqR1F0OPF19SwI5MDEQTCO0t/mEmVPKH0wVAAAAA10RVh0QXV0aG9yAG1pbW9vaA6yENgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjNU");
            sb.Append("MTY6MzY6MTktMDc6MDBIk8sPAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAyLTIzVDE2OjM2OjE5LTA3OjAwOc5zswAAADJ0RVh0TGljZW5zZQBodHRwOi8vZW4ud2lr");
            sb.Append("aXBlZGlhLm9yZy93aWtpL1B1YmxpY19kb21haW4//erPAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABx0RVh0U291cmNlAE9wZW4gQ2xpcCBB");
            sb.Append("cnQgTGlicmFyeZjHSPcAAAAhdEVYdFNvdXJjZV9VUkwAaHR0cDovL29wZW5jbGlwYXJ0Lm9yZ0W2VHAAAAAKdEVYdFRpdGxlAGNoaXABMT/aAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property MemoryRom_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void MemoryRom_Reset()
        {
            _MemoryRom = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití MemoryRom_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _MemoryRom = null;
        #endregion
        #region Image ViewGrid
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku view-grid.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ViewGrid_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ViewGrid, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ViewGrid_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-grid.png
        /// </remarks>
        public static System.Drawing.Image ViewGrid_Cached
        {
            get
            {
                if (_ViewGrid == null) _ViewGrid = ViewGrid;
                return _ViewGrid;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku view-grid.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ViewGrid_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ViewGrid_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ViewGrid_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-grid.png
        /// </remarks>
        public static System.Drawing.Image ViewGrid { get { return _ImageCreateFrom(_ViewGrid_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru view-grid.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ViewGrid_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ViewGrid_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-grid.png
        /// </remarks>
        public static System.Drawing.Image ViewGrid_FromFile { get { return _ImageCreateFrom(_ViewGrid_string, "view-grid.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ViewGrid
        /// </summary>
        /// <returns></returns>
        private static string _ViewGrid_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1748);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAZdEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAAEgklEQVRIS7XVeWwUVRwH8IcBE4yCmkAol8Yj0kILBcEuyFGgXLVyCRKCQROk3e2JJiYaU9HAVqka");
            sb.Append("bNlaOQrSgx4UKxa6pdUCQht7ASKl11K2nbZri73sMd3Z33z9ze5WC3/Uv5jkk9/Lm5mXvO/8XkaIh3WNG2eo8lu0T9UtjqH5C400j83VMT8j+bI5zOcVI3m+bKQXfI00");
            sb.Append("3cdIUzXeRprCJrtNmrWfJnnH0ESv/eqYx/RWsWipkXKqenHyFuFohYLD5QoSSxWYflMQV6LgYLGCA78qiC5QsCdXwa7TCnamK9hxSsH2NAXbUhVsSVGwOVnBphRC4HEZ");
            sb.Append("E3y+JLF0RSzFXhnEVn5o8wkZG/nGhiQZ61nQMRmvHZWx9rAMf5MM3UEZvrEyvL+QMetzGTNjZHgZZczYL8OT60sxdviZHJgwN47E4pUHSf9dI96OrcOeby0IP1SPCJNl");
            sb.Append("RJEJFgyJ4nFUQj0M/F5ofB10n0gY72MiMW/JNxSdchdSWy8AFQ5SuDpGoN2/n6ra0dEzgN7efmyPt2H0jAQSvkvj6cNkK5raBvgFXpJUZx1+qaoKchAUxYHBQQWybMfA");
            sb.Append("gGaQyRjoH4Dtrz509/Rha9yfGO2VSMJnWQIFvZmMEEMGIiOzEBGR5awPiojIRHi4JgNhYQ9Kh96QjtDQdKx+60c8MvMIiVn+ifT+CSsKiupx7VoTKiobnXW4Sp4rL7ei");
            sb.Append("tLQBJSUWXL1a71bHlV2pRcHPNbhyuQbr91ZDeB8l4bn8MEUds3LG/SNGYbcr6O+X0cPb7erqRWfn36zHpaMbjS1d6LjXhY1f2yBmHycxY8UxWrd15Ci0eLQYtAi07WoM");
            sb.Append("vHWD4dS/gkNc44AdObzwCRIvBhwnw5H/j0KLobjYgsuXa3HxYg2KiqrZbVaFol+qcM7sqoHRHMWcZBLPrzpJwYn3R8FNAK0ThjgcDo5hEN3dfWhv74bN1onW1g60tNxj");
            sb.Append("7WhpbkeNpQ02roEHOIq5qSSeXZ1Ca7YMjyLT3R2Z3CH/GYpBrz8FvT4NISFDUnmcind3u+rybdkQ89JJTF+TRu+YrCh0d4X29SsqGpnV2QllZa5u0Drh0qUaFBbeQn7+");
            sb.Append("TSez+XeY8244nTl7HRfyryPg41peOJPElLUZtPOQFc3urtAOgcZudx0GjXYQtE5oa+tEU1MbGhpsuHOnFZb6ZljqJNaEG380wXqnGauMHMX80yQ81mXRqjeSucGHDogW");
            sb.Append("xTDuOMLCuBv4q+t5uyHBKQjW7B6SjF27Upzz/htT8bgug8TkoB9oy1d3kXHmJsdRi/zCalYDc0E1zBc0t3E+vwo/nbuJnLM3kH2mElnZFcg8zbLKWZnT92llyM4uw7LI");
            sb.Append("6xityyExbUOOGmjqgL9RwrJ9EpZ8JuHVTyUsYgv3StCxBdESZn8kwfMDCc+9J+GZqGZMj5IwLVLC1AgJU5hHeDM8wiSMDe2CWJ6rikf9kho8NueqEzeZ6en1efQUe/J1");
            sb.Append("l/FuTwTl0dh1eTRmTR6NCsgjoVn5oPM8Z6ZRK8+pYkFS68P64z28df8Bl8K+G4r9oNcAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ViewGrid_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ViewGrid_Reset()
        {
            _ViewGrid = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ViewGrid_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ViewGrid = null;
        #endregion
        #region Image ViewSplitDetail
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku view-split-detail.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ViewSplitDetail_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ViewSplitDetail, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ViewSplitDetail_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-split-detail.png
        /// </remarks>
        public static System.Drawing.Image ViewSplitDetail_Cached
        {
            get
            {
                if (_ViewSplitDetail == null) _ViewSplitDetail = ViewSplitDetail;
                return _ViewSplitDetail;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku view-split-detail.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ViewSplitDetail_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ViewSplitDetail_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ViewSplitDetail_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-split-detail.png
        /// </remarks>
        public static System.Drawing.Image ViewSplitDetail { get { return _ImageCreateFrom(_ViewSplitDetail_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru view-split-detail.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ViewSplitDetail_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ViewSplitDetail_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic22\view-split-detail.png
        /// </remarks>
        public static System.Drawing.Image ViewSplitDetail_FromFile { get { return _ImageCreateFrom(_ViewSplitDetail_string, "view-split-detail.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ViewSplitDetail
        /// </summary>
        /// <returns></returns>
        private static string _ViewSplitDetail_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1884);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABYAAAAWCAYAAADEtGw7AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAZdEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAAE6ElEQVRIS7WVe0xTdxTHf25q9sh0W6KZTjedc76rgiCIoCiiiG+nMWbGLTEqICjOzbkoOoPFyZhT");
            sb.Append("REFRVBBBTXQOrQ8cxgEBUd4yp0BbeltKeZRKgdvenn73uxXndNP/PMknJ7m/20/OPefcXsZeVfTqFVrl5RPt9PaNIY9JSnLnuHkpaRxHMVFJoz2VNMpDSSMmKOkzdyUN");
            sb.Append("dVPSEM7gcUr6eKySBiqUNIDTf4ySPhgTQ31H7nL2eCtEy3ymKOlClRUn7xGS70pILJKwv0BCXJ6EH/+QEH1Two4bErZek7BZJWHjJQnhFyWsPS9h1TkJKzMlLD8tYUmq");
            sb.Append("hEVphOAUEX0UPxGbMj2WYnNtWJouYfFxEQv5wbxjIoKTRcw6LCIgUURgkg1zTjjhd8CGSftEeO4V4R4nYnysCMUeEaN3ixi+S8SwGDu8Ehzo47afmG/ALxSSVIcvYx8i");
            sb.Append("8lANIhKeZdNhDVZEl6O/fwZWxf6JyCQ1Ig7WYH0XG3iW2ZhUg7D4h/DeLqC3IoGYu98+ikrTQDBZATg5jucAKso08PfdhSaTmZ/J8fw9Er8mwWrtwPJ4I7oPP0hs/JR4");
            sb.Append("2pKqhc7U2fWj/6aycgF+AXthbHjkOnQ6nSAHQbI7YLNJ6Oy0wy6KsDxqx9L9Deg+MpGYYupB+vb4y8WlFXr4zdyHqKgsrF9/FhERZxAeLpPpYt06njmRkWfxeawOr406");
            sb.Append("Qmy0fyJ9zcWCqeOFFbvEQQkoK9ejpESHoiINCgvVKCioRX5+NfLyqpGf9xCFBdVYvLcBbEwysRHTDtOGo/8v5k/sClnsO+cQBEOrawydnTa0t4toa+uAxdIOs7kNFvMj");
            sb.Append("tDS1YuHPRrCxKcSGTz9K4ckvEj82l1YaMHleEur0rSBy/Etq5VIrmposaG4y8+G2YH6cLD5ObOiMFAo98nJxSWU9Ji84iq3bfnP1V+5pWJhMBkJDMxASchqhLtIRvLMW");
            sb.Append("bFwqsSGBJ2lN4rNiuQXy5B188nLIYp9FKSgqrsPt22rk5lbj1q0HuHnzL+Tk3Ed2dhVuZFfid07wHl6x2ylig2am0apDWui7hicLn0jtfJ3+ES85gRptEzraO9Hc3IbG");
            sb.Append("RguMRjPq65uh0zVC0DVAzwnazcXuGcQ+mpVOXyU8FRORq1JZKop210tTzCuetDQV1epGWPnAZGlDgxkGw2OpRtMAjboeOq0BgTGy+AyxD4MyaeWBp2JJeiyVF7+jw8a9");
            sb.Append("hLuVRngvS8d33//q6qvc0xDez7Vr07FmzSmsXi2Txnf5NGZsqwHzOEes3+yztCJeC0Pjkz2WN4H3lk/fYZcrJpRU8R5/kYnCIr67+Q9wK6cKOTcqkX29HNeuluLK5RJc");
            sb.Append("zrqL66oSBEUbwCaeJ9Z/7nlaEqfBnQoTDKY2aPQWaHQyZtRqWmAwWnA1V40JyzKRd0eL6loT7t2vR8U9A8oqBJSW16G4VIviEjXKytSYul0P5n2R2MAFF5zBCS3wVwqY");
            sb.Append("Gi3Ad6cAnx8EeO0Q4Mn/qTyi9FBs0WFwRC1GbRYwcrMew77R49NNenyyUY9BkXoM3KDHgAgB/dYJeDOsFWxalpP19Dqm7rc4y9l30RV6f76K3lugonfnqag35525Kno7");
            sb.Append("mDNHRb3mX6U3ZquoZ5CKesxU0eucboEqYjO6COA54Ap1C7jkZJ7H6l/VF+/Vef8Gy4z9OIXZr/IAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ViewSplitDetail_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ViewSplitDetail_Reset()
        {
            _ViewSplitDetail = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ViewSplitDetail_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ViewSplitDetail = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
		/// <summary>
		/// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
		/// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
		/// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
		/// Pokud soubor neexistuje, nejprve se vytvoří.
		/// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
		/// Obsah obrázku definuje metoda getDataMethod.
		/// </summary>
		/// <param name="getDataMethod"></param>
		/// <param name="cacheFileName"></param>
		/// <returns></returns>
		private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
		{
			System.Drawing.Image image;
			if (cacheFileName == null)
			{
				using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
				{
					image = System.Drawing.Image.FromStream(ms);
				}
				return image;
			}
			string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
			if (!System.IO.File.Exists(fileName))
				System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
			if (System.IO.File.Exists(fileName))
				return Image.FromFile(fileName);
			return null;
		}
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Noris.Tools.TraceVisualiser.Support.Steward.GetUserAppDataPath(@"IconCache\Pics22");
                return __ImageCacheDir;
            }
        }
        private static string __ImageCacheDir;
		/// <summary>
		/// Předpis pro metody, které generují obsah souboru s daty
		/// </summary>
		/// <returns></returns>
		private delegate string _GetStringDelegate();
		/// <summary>
		/// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Icon vytvořená z dat</returns>
		public static System.Drawing.Icon ConvertStringToIcon(string data)
		{
			System.Drawing.Icon icon;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				icon = new System.Drawing.Icon(ms);
			}
			return icon;
		}
		/// <summary>
		/// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Cursor vytvořený z dat</returns>
		public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
		{
			System.Windows.Forms.Cursor cursor;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				cursor = new System.Windows.Forms.Cursor(ms);
			}
			return cursor;
		}
		#endregion
	}
}
